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

#ifndef GOOGLE_PROTOBUF_INCLUDED_message_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_message_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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_message_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_message_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[47]
    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_message_2eproto;
namespace milvus {
namespace grpc {
class BoolReply;
class BoolReplyDefaultTypeInternal;
extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_;
class BooleanQuery;
class BooleanQueryDefaultTypeInternal;
extern BooleanQueryDefaultTypeInternal _BooleanQuery_default_instance_;
class CollectionInfo;
class CollectionInfoDefaultTypeInternal;
extern CollectionInfoDefaultTypeInternal _CollectionInfo_default_instance_;
class CollectionName;
class CollectionNameDefaultTypeInternal;
extern CollectionNameDefaultTypeInternal _CollectionName_default_instance_;
class CollectionNameList;
class CollectionNameListDefaultTypeInternal;
extern CollectionNameListDefaultTypeInternal _CollectionNameList_default_instance_;
class CollectionRowCount;
class CollectionRowCountDefaultTypeInternal;
extern CollectionRowCountDefaultTypeInternal _CollectionRowCount_default_instance_;
class Command;
class CommandDefaultTypeInternal;
extern CommandDefaultTypeInternal _Command_default_instance_;
class CompactParam;
class CompactParamDefaultTypeInternal;
extern CompactParamDefaultTypeInternal _CompactParam_default_instance_;
class CompareExpr;
class CompareExprDefaultTypeInternal;
extern CompareExprDefaultTypeInternal _CompareExpr_default_instance_;
class DeleteByIDParam;
class DeleteByIDParamDefaultTypeInternal;
extern DeleteByIDParamDefaultTypeInternal _DeleteByIDParam_default_instance_;
class Entities;
class EntitiesDefaultTypeInternal;
extern EntitiesDefaultTypeInternal _Entities_default_instance_;
class EntityIdentity;
class EntityIdentityDefaultTypeInternal;
extern EntityIdentityDefaultTypeInternal _EntityIdentity_default_instance_;
class EntityIds;
class EntityIdsDefaultTypeInternal;
extern EntityIdsDefaultTypeInternal _EntityIds_default_instance_;
class FieldMeta;
class FieldMetaDefaultTypeInternal;
extern FieldMetaDefaultTypeInternal _FieldMeta_default_instance_;
class FieldName;
class FieldNameDefaultTypeInternal;
extern FieldNameDefaultTypeInternal _FieldName_default_instance_;
class FieldParam;
class FieldParamDefaultTypeInternal;
extern FieldParamDefaultTypeInternal _FieldParam_default_instance_;
class FieldType;
class FieldTypeDefaultTypeInternal;
extern FieldTypeDefaultTypeInternal _FieldType_default_instance_;
class FlushParam;
class FlushParamDefaultTypeInternal;
extern FlushParamDefaultTypeInternal _FlushParam_default_instance_;
class GeneralQuery;
class GeneralQueryDefaultTypeInternal;
extern GeneralQueryDefaultTypeInternal _GeneralQuery_default_instance_;
class GetEntityIDsParam;
class GetEntityIDsParamDefaultTypeInternal;
extern GetEntityIDsParamDefaultTypeInternal _GetEntityIDsParam_default_instance_;
class IndexParam;
class IndexParamDefaultTypeInternal;
extern IndexParamDefaultTypeInternal _IndexParam_default_instance_;
class InsertOrDeleteMsg;
class InsertOrDeleteMsgDefaultTypeInternal;
extern InsertOrDeleteMsgDefaultTypeInternal _InsertOrDeleteMsg_default_instance_;
class InsertParam;
class InsertParamDefaultTypeInternal;
extern InsertParamDefaultTypeInternal _InsertParam_default_instance_;
class Key2SegMsg;
class Key2SegMsgDefaultTypeInternal;
extern Key2SegMsgDefaultTypeInternal _Key2SegMsg_default_instance_;
class KeyValuePair;
class KeyValuePairDefaultTypeInternal;
extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_;
class Mapping;
class MappingDefaultTypeInternal;
extern MappingDefaultTypeInternal _Mapping_default_instance_;
class MappingList;
class MappingListDefaultTypeInternal;
extern MappingListDefaultTypeInternal _MappingList_default_instance_;
class PartitionList;
class PartitionListDefaultTypeInternal;
extern PartitionListDefaultTypeInternal _PartitionList_default_instance_;
class PartitionParam;
class PartitionParamDefaultTypeInternal;
extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_;
class QueryResult;
class QueryResultDefaultTypeInternal;
extern QueryResultDefaultTypeInternal _QueryResult_default_instance_;
class RangeQuery;
class RangeQueryDefaultTypeInternal;
extern RangeQueryDefaultTypeInternal _RangeQuery_default_instance_;
class RowData;
class RowDataDefaultTypeInternal;
extern RowDataDefaultTypeInternal _RowData_default_instance_;
class Schema;
class SchemaDefaultTypeInternal;
extern SchemaDefaultTypeInternal _Schema_default_instance_;
class SearchInSegmentParam;
class SearchInSegmentParamDefaultTypeInternal;
extern SearchInSegmentParamDefaultTypeInternal _SearchInSegmentParam_default_instance_;
class SearchMsg;
class SearchMsgDefaultTypeInternal;
extern SearchMsgDefaultTypeInternal _SearchMsg_default_instance_;
class SearchParam;
class SearchParamDefaultTypeInternal;
extern SearchParamDefaultTypeInternal _SearchParam_default_instance_;
class SearchParamPB;
class SearchParamPBDefaultTypeInternal;
extern SearchParamPBDefaultTypeInternal _SearchParamPB_default_instance_;
class Status;
class StatusDefaultTypeInternal;
extern StatusDefaultTypeInternal _Status_default_instance_;
class StringReply;
class StringReplyDefaultTypeInternal;
extern StringReplyDefaultTypeInternal _StringReply_default_instance_;
class TermQuery;
class TermQueryDefaultTypeInternal;
extern TermQueryDefaultTypeInternal _TermQuery_default_instance_;
class TimeSyncMsg;
class TimeSyncMsgDefaultTypeInternal;
extern TimeSyncMsgDefaultTypeInternal _TimeSyncMsg_default_instance_;
class VectorFieldParam;
class VectorFieldParamDefaultTypeInternal;
extern VectorFieldParamDefaultTypeInternal _VectorFieldParam_default_instance_;
class VectorFieldRecord;
class VectorFieldRecordDefaultTypeInternal;
extern VectorFieldRecordDefaultTypeInternal _VectorFieldRecord_default_instance_;
class VectorParam;
class VectorParamDefaultTypeInternal;
extern VectorParamDefaultTypeInternal _VectorParam_default_instance_;
class VectorQuery;
class VectorQueryDefaultTypeInternal;
extern VectorQueryDefaultTypeInternal _VectorQuery_default_instance_;
class VectorRecord;
class VectorRecordDefaultTypeInternal;
extern VectorRecordDefaultTypeInternal _VectorRecord_default_instance_;
class VectorRowRecord;
class VectorRowRecordDefaultTypeInternal;
extern VectorRowRecordDefaultTypeInternal _VectorRowRecord_default_instance_;
}  // namespace grpc
}  // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*);
template<> ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage<::milvus::grpc::BooleanQuery>(Arena*);
template<> ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage<::milvus::grpc::CollectionInfo>(Arena*);
template<> ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage<::milvus::grpc::CollectionName>(Arena*);
template<> ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage<::milvus::grpc::CollectionNameList>(Arena*);
template<> ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage<::milvus::grpc::CollectionRowCount>(Arena*);
template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*);
template<> ::milvus::grpc::CompactParam* Arena::CreateMaybeMessage<::milvus::grpc::CompactParam>(Arena*);
template<> ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage<::milvus::grpc::CompareExpr>(Arena*);
template<> ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByIDParam>(Arena*);
template<> ::milvus::grpc::Entities* Arena::CreateMaybeMessage<::milvus::grpc::Entities>(Arena*);
template<> ::milvus::grpc::EntityIdentity* Arena::CreateMaybeMessage<::milvus::grpc::EntityIdentity>(Arena*);
template<> ::milvus::grpc::EntityIds* Arena::CreateMaybeMessage<::milvus::grpc::EntityIds>(Arena*);
template<> ::milvus::grpc::FieldMeta* Arena::CreateMaybeMessage<::milvus::grpc::FieldMeta>(Arena*);
template<> ::milvus::grpc::FieldName* Arena::CreateMaybeMessage<::milvus::grpc::FieldName>(Arena*);
template<> ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage<::milvus::grpc::FieldParam>(Arena*);
template<> ::milvus::grpc::FieldType* Arena::CreateMaybeMessage<::milvus::grpc::FieldType>(Arena*);
template<> ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage<::milvus::grpc::FlushParam>(Arena*);
template<> ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage<::milvus::grpc::GeneralQuery>(Arena*);
template<> ::milvus::grpc::GetEntityIDsParam* Arena::CreateMaybeMessage<::milvus::grpc::GetEntityIDsParam>(Arena*);
template<> ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage<::milvus::grpc::IndexParam>(Arena*);
template<> ::milvus::grpc::InsertOrDeleteMsg* Arena::CreateMaybeMessage<::milvus::grpc::InsertOrDeleteMsg>(Arena*);
template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc::InsertParam>(Arena*);
template<> ::milvus::grpc::Key2SegMsg* Arena::CreateMaybeMessage<::milvus::grpc::Key2SegMsg>(Arena*);
template<> ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage<::milvus::grpc::KeyValuePair>(Arena*);
template<> ::milvus::grpc::Mapping* Arena::CreateMaybeMessage<::milvus::grpc::Mapping>(Arena*);
template<> ::milvus::grpc::MappingList* Arena::CreateMaybeMessage<::milvus::grpc::MappingList>(Arena*);
template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*);
template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*);
template<> ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage<::milvus::grpc::QueryResult>(Arena*);
template<> ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage<::milvus::grpc::RangeQuery>(Arena*);
template<> ::milvus::grpc::RowData* Arena::CreateMaybeMessage<::milvus::grpc::RowData>(Arena*);
template<> ::milvus::grpc::Schema* Arena::CreateMaybeMessage<::milvus::grpc::Schema>(Arena*);
template<> ::milvus::grpc::SearchInSegmentParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInSegmentParam>(Arena*);
template<> ::milvus::grpc::SearchMsg* Arena::CreateMaybeMessage<::milvus::grpc::SearchMsg>(Arena*);
template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*);
template<> ::milvus::grpc::SearchParamPB* Arena::CreateMaybeMessage<::milvus::grpc::SearchParamPB>(Arena*);
template<> ::milvus::grpc::Status* Arena::CreateMaybeMessage<::milvus::grpc::Status>(Arena*);
template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*);
template<> ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage<::milvus::grpc::TermQuery>(Arena*);
template<> ::milvus::grpc::TimeSyncMsg* Arena::CreateMaybeMessage<::milvus::grpc::TimeSyncMsg>(Arena*);
template<> ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldParam>(Arena*);
template<> ::milvus::grpc::VectorFieldRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldRecord>(Arena*);
template<> ::milvus::grpc::VectorParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorParam>(Arena*);
template<> ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage<::milvus::grpc::VectorQuery>(Arena*);
template<> ::milvus::grpc::VectorRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorRecord>(Arena*);
template<> ::milvus::grpc::VectorRowRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorRowRecord>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
namespace grpc {

enum ErrorCode : int {
  SUCCESS = 0,
  UNEXPECTED_ERROR = 1,
  CONNECT_FAILED = 2,
  PERMISSION_DENIED = 3,
  COLLECTION_NOT_EXISTS = 4,
  ILLEGAL_ARGUMENT = 5,
  ILLEGAL_DIMENSION = 7,
  ILLEGAL_INDEX_TYPE = 8,
  ILLEGAL_COLLECTION_NAME = 9,
  ILLEGAL_TOPK = 10,
  ILLEGAL_ROWRECORD = 11,
  ILLEGAL_VECTOR_ID = 12,
  ILLEGAL_SEARCH_RESULT = 13,
  FILE_NOT_FOUND = 14,
  META_FAILED = 15,
  CACHE_FAILED = 16,
  CANNOT_CREATE_FOLDER = 17,
  CANNOT_CREATE_FILE = 18,
  CANNOT_DELETE_FOLDER = 19,
  CANNOT_DELETE_FILE = 20,
  BUILD_INDEX_ERROR = 21,
  ILLEGAL_NLIST = 22,
  ILLEGAL_METRIC_TYPE = 23,
  OUT_OF_MEMORY = 24,
  ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ErrorCode_IsValid(int value);
constexpr ErrorCode ErrorCode_MIN = SUCCESS;
constexpr ErrorCode ErrorCode_MAX = OUT_OF_MEMORY;
constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
template<typename T>
inline const std::string& ErrorCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ErrorCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ErrorCode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ErrorCode_descriptor(), enum_t_value);
}
inline bool ErrorCode_Parse(
    const std::string& name, ErrorCode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
    ErrorCode_descriptor(), name, value);
}
enum DataType : int {
  NONE = 0,
  BOOL = 1,
  INT8 = 2,
  INT16 = 3,
  INT32 = 4,
  INT64 = 5,
  FLOAT = 10,
  DOUBLE = 11,
  STRING = 20,
  VECTOR_BINARY = 100,
  VECTOR_FLOAT = 101,
  DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DataType_IsValid(int value);
constexpr DataType DataType_MIN = NONE;
constexpr DataType DataType_MAX = VECTOR_FLOAT;
constexpr int DataType_ARRAYSIZE = DataType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor();
template<typename T>
inline const std::string& DataType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DataType_descriptor(), enum_t_value);
}
inline bool DataType_Parse(
    const std::string& name, DataType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataType>(
    DataType_descriptor(), name, value);
}
enum CompareOperator : int {
  LT = 0,
  LTE = 1,
  EQ = 2,
  GT = 3,
  GTE = 4,
  NE = 5,
  CompareOperator_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CompareOperator_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CompareOperator_IsValid(int value);
constexpr CompareOperator CompareOperator_MIN = LT;
constexpr CompareOperator CompareOperator_MAX = NE;
constexpr int CompareOperator_ARRAYSIZE = CompareOperator_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor();
template<typename T>
inline const std::string& CompareOperator_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CompareOperator>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CompareOperator_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CompareOperator_descriptor(), enum_t_value);
}
inline bool CompareOperator_Parse(
    const std::string& name, CompareOperator* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CompareOperator>(
    CompareOperator_descriptor(), name, value);
}
enum Occur : int {
  INVALID = 0,
  MUST = 1,
  SHOULD = 2,
  MUST_NOT = 3,
  Occur_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Occur_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Occur_IsValid(int value);
constexpr Occur Occur_MIN = INVALID;
constexpr Occur Occur_MAX = MUST_NOT;
constexpr int Occur_ARRAYSIZE = Occur_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor();
template<typename T>
inline const std::string& Occur_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Occur>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Occur_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Occur_descriptor(), enum_t_value);
}
inline bool Occur_Parse(
    const std::string& name, Occur* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Occur>(
    Occur_descriptor(), name, value);
}
enum OpType : int {
  INSERT = 0,
  DELETE = 1,
  OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool OpType_IsValid(int value);
constexpr OpType OpType_MIN = INSERT;
constexpr OpType OpType_MAX = DELETE;
constexpr int OpType_ARRAYSIZE = OpType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor();
template<typename T>
inline const std::string& OpType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OpType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OpType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OpType_descriptor(), enum_t_value);
}
inline bool OpType_Parse(
    const std::string& name, OpType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OpType>(
    OpType_descriptor(), name, value);
}
enum SyncType : int {
  READ = 0,
  WRITE = 1,
  SyncType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SyncType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SyncType_IsValid(int value);
constexpr SyncType SyncType_MIN = READ;
constexpr SyncType SyncType_MAX = WRITE;
constexpr int SyncType_ARRAYSIZE = SyncType_MAX + 1;

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

class Status :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Status) */ {
 public:
  Status();
  virtual ~Status();

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

  inline Status& operator=(const Status& from) {
    CopyFrom(from);
    return *this;
  }
  inline Status& operator=(Status&& 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 Status& default_instance();

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

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

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

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

  Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Status>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Status& from);
  void MergeFrom(const Status& 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(Status* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.Status";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kReasonFieldNumber = 2,
    kErrorCodeFieldNumber = 1,
  };
  // string reason = 2;
  void clear_reason();
  const std::string& reason() const;
  void set_reason(const std::string& value);
  void set_reason(std::string&& value);
  void set_reason(const char* value);
  void set_reason(const char* value, size_t size);
  std::string* mutable_reason();
  std::string* release_reason();
  void set_allocated_reason(std::string* reason);

  // .milvus.grpc.ErrorCode error_code = 1;
  void clear_error_code();
  ::milvus::grpc::ErrorCode error_code() const;
  void set_error_code(::milvus::grpc::ErrorCode value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.Status)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
  int error_code_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class KeyValuePair :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.KeyValuePair) */ {
 public:
  KeyValuePair();
  virtual ~KeyValuePair();

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

  inline KeyValuePair& operator=(const KeyValuePair& from) {
    CopyFrom(from);
    return *this;
  }
  inline KeyValuePair& operator=(KeyValuePair&& 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 KeyValuePair& default_instance();

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

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

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

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

  KeyValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<KeyValuePair>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const KeyValuePair& from);
  void MergeFrom(const KeyValuePair& 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(KeyValuePair* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.KeyValuePair";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);

  // 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);

  // @@protoc_insertion_point(class_scope:milvus.grpc.KeyValuePair)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class CollectionName :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.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 =
    2;

  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.grpc.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_message_2eproto);
    return ::descriptor_table_message_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.grpc.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_message_2eproto;
};
// -------------------------------------------------------------------

class CollectionNameList :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionNameList) */ {
 public:
  CollectionNameList();
  virtual ~CollectionNameList();

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

  inline CollectionNameList& operator=(const CollectionNameList& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollectionNameList& operator=(CollectionNameList&& 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 CollectionNameList& default_instance();

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

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

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

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

  CollectionNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollectionNameList>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollectionNameList& from);
  void MergeFrom(const CollectionNameList& 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(CollectionNameList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.CollectionNameList";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNamesFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated string collection_names = 2;
  int collection_names_size() const;
  void clear_collection_names();
  const std::string& collection_names(int index) const;
  std::string* mutable_collection_names(int index);
  void set_collection_names(int index, const std::string& value);
  void set_collection_names(int index, std::string&& value);
  void set_collection_names(int index, const char* value);
  void set_collection_names(int index, const char* value, size_t size);
  std::string* add_collection_names();
  void add_collection_names(const std::string& value);
  void add_collection_names(std::string&& value);
  void add_collection_names(const char* value);
  void add_collection_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& collection_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_collection_names();

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionNameList)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> collection_names_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class FieldName :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldName) */ {
 public:
  FieldName();
  virtual ~FieldName();

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

  inline FieldName& operator=(const FieldName& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldName& operator=(FieldName&& 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 FieldName& default_instance();

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

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

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

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

  FieldName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FieldName>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FieldName& from);
  void MergeFrom(const FieldName& 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(FieldName* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.FieldName";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNameFieldNumber = 1,
    kFieldNameFieldNumber = 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 field_name = 2;
  void clear_field_name();
  const std::string& field_name() const;
  void set_field_name(const std::string& value);
  void set_field_name(std::string&& value);
  void set_field_name(const char* value);
  void set_field_name(const char* value, size_t size);
  std::string* mutable_field_name();
  std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);

  // @@protoc_insertion_point(class_scope:milvus.grpc.FieldName)
 private:
  class _Internal;

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

class Mapping :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Mapping) */ {
 public:
  Mapping();
  virtual ~Mapping();

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

  inline Mapping& operator=(const Mapping& from) {
    CopyFrom(from);
    return *this;
  }
  inline Mapping& operator=(Mapping&& 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 Mapping& default_instance();

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

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

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

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

  Mapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Mapping>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Mapping& from);
  void MergeFrom(const Mapping& 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(Mapping* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.Mapping";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kExtraParamsFieldNumber = 4,
    kCollectionNameFieldNumber = 2,
    kStatusFieldNumber = 1,
    kSchemaFieldNumber = 3,
  };
  // repeated .milvus.grpc.KeyValuePair extra_params = 4;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // string collection_name = 2;
  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);

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

  // .milvus.grpc.Schema schema = 3;
  bool has_schema() const;
  void clear_schema();
  const ::milvus::grpc::Schema& schema() const;
  ::milvus::grpc::Schema* release_schema();
  ::milvus::grpc::Schema* mutable_schema();
  void set_allocated_schema(::milvus::grpc::Schema* schema);

  // @@protoc_insertion_point(class_scope:milvus.grpc.Mapping)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::milvus::grpc::Status* status_;
  ::milvus::grpc::Schema* schema_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class MappingList :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.MappingList) */ {
 public:
  MappingList();
  virtual ~MappingList();

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

  inline MappingList& operator=(const MappingList& from) {
    CopyFrom(from);
    return *this;
  }
  inline MappingList& operator=(MappingList&& 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 MappingList& default_instance();

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

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

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

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

  MappingList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MappingList>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MappingList& from);
  void MergeFrom(const MappingList& 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(MappingList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.MappingList";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMappingListFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated .milvus.grpc.Mapping mapping_list = 2;
  int mapping_list_size() const;
  void clear_mapping_list();
  ::milvus::grpc::Mapping* mutable_mapping_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >*
      mutable_mapping_list();
  const ::milvus::grpc::Mapping& mapping_list(int index) const;
  ::milvus::grpc::Mapping* add_mapping_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >&
      mapping_list() const;

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.MappingList)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping > mapping_list_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class PartitionParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.PartitionParam) */ {
 public:
  PartitionParam();
  virtual ~PartitionParam();

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

  inline PartitionParam& operator=(const PartitionParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionParam& operator=(PartitionParam&& 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 PartitionParam& default_instance();

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

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

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

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

  PartitionParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionParam& from);
  void MergeFrom(const PartitionParam& 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(PartitionParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.PartitionParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_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.grpc.PartitionParam)
 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_message_2eproto;
};
// -------------------------------------------------------------------

class PartitionList :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.PartitionList) */ {
 public:
  PartitionList();
  virtual ~PartitionList();

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

  inline PartitionList& operator=(const PartitionList& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionList& operator=(PartitionList&& 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 PartitionList& default_instance();

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

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

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

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

  PartitionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionList>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionList& from);
  void MergeFrom(const PartitionList& 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(PartitionList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.PartitionList";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPartitionTagArrayFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated string partition_tag_array = 2;
  int partition_tag_array_size() const;
  void clear_partition_tag_array();
  const std::string& partition_tag_array(int index) const;
  std::string* mutable_partition_tag_array(int index);
  void set_partition_tag_array(int index, const std::string& value);
  void set_partition_tag_array(int index, std::string&& value);
  void set_partition_tag_array(int index, const char* value);
  void set_partition_tag_array(int index, const char* value, size_t size);
  std::string* add_partition_tag_array();
  void add_partition_tag_array(const std::string& value);
  void add_partition_tag_array(std::string&& value);
  void add_partition_tag_array(const char* value);
  void add_partition_tag_array(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tag_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tag_array();

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.PartitionList)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_tag_array_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class VectorRowRecord :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorRowRecord) */ {
 public:
  VectorRowRecord();
  virtual ~VectorRowRecord();

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

  inline VectorRowRecord& operator=(const VectorRowRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorRowRecord& operator=(VectorRowRecord&& 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 VectorRowRecord& default_instance();

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

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

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

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

  VectorRowRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VectorRowRecord>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VectorRowRecord& from);
  void MergeFrom(const VectorRowRecord& 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(VectorRowRecord* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.VectorRowRecord";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFloatDataFieldNumber = 1,
    kBinaryDataFieldNumber = 2,
  };
  // repeated float float_data = 1;
  int float_data_size() const;
  void clear_float_data();
  float float_data(int index) const;
  void set_float_data(int index, float value);
  void add_float_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      float_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_float_data();

  // bytes binary_data = 2;
  void clear_binary_data();
  const std::string& binary_data() const;
  void set_binary_data(const std::string& value);
  void set_binary_data(std::string&& value);
  void set_binary_data(const char* value);
  void set_binary_data(const void* value, size_t size);
  std::string* mutable_binary_data();
  std::string* release_binary_data();
  void set_allocated_binary_data(std::string* binary_data);

  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorRowRecord)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
  mutable std::atomic<int> _float_data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class EntityIds :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.EntityIds) */ {
 public:
  EntityIds();
  virtual ~EntityIds();

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

  inline EntityIds& operator=(const EntityIds& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntityIds& operator=(EntityIds&& 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 EntityIds& default_instance();

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

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

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

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

  EntityIds* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EntityIds>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const EntityIds& from);
  void MergeFrom(const EntityIds& 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(EntityIds* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.EntityIds";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kEntityIdArrayFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated int64 entity_id_array = 2;
  int entity_id_array_size() const;
  void clear_entity_id_array();
  ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const;
  void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      entity_id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_entity_id_array();

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.EntityIds)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_;
  mutable std::atomic<int> _entity_id_array_cached_byte_size_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class VectorRecord :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorRecord) */ {
 public:
  VectorRecord();
  virtual ~VectorRecord();

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

  inline VectorRecord& operator=(const VectorRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorRecord& operator=(VectorRecord&& 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 VectorRecord& default_instance();

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

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

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

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

  VectorRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VectorRecord>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VectorRecord& from);
  void MergeFrom(const VectorRecord& 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(VectorRecord* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.VectorRecord";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRecordsFieldNumber = 1,
  };
  // repeated .milvus.grpc.VectorRowRecord records = 1;
  int records_size() const;
  void clear_records();
  ::milvus::grpc::VectorRowRecord* mutable_records(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >*
      mutable_records();
  const ::milvus::grpc::VectorRowRecord& records(int index) const;
  ::milvus::grpc::VectorRowRecord* add_records();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >&
      records() const;

  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorRecord)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord > records_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class VectorParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorParam) */ {
 public:
  VectorParam();
  virtual ~VectorParam();

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

  inline VectorParam& operator=(const VectorParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorParam& operator=(VectorParam&& 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 VectorParam& default_instance();

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

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

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

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

  VectorParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VectorParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VectorParam& from);
  void MergeFrom(const VectorParam& 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(VectorParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.VectorParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kJsonFieldNumber = 1,
    kRowRecordFieldNumber = 2,
  };
  // string json = 1;
  void clear_json();
  const std::string& json() const;
  void set_json(const std::string& value);
  void set_json(std::string&& value);
  void set_json(const char* value);
  void set_json(const char* value, size_t size);
  std::string* mutable_json();
  std::string* release_json();
  void set_allocated_json(std::string* json);

  // .milvus.grpc.VectorRecord row_record = 2;
  bool has_row_record() const;
  void clear_row_record();
  const ::milvus::grpc::VectorRecord& row_record() const;
  ::milvus::grpc::VectorRecord* release_row_record();
  ::milvus::grpc::VectorRecord* mutable_row_record();
  void set_allocated_row_record(::milvus::grpc::VectorRecord* row_record);

  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_;
  ::milvus::grpc::VectorRecord* row_record_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class FieldMeta :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldMeta) */ {
 public:
  FieldMeta();
  virtual ~FieldMeta();

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

  inline FieldMeta& operator=(const FieldMeta& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldMeta& operator=(FieldMeta&& 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 FieldMeta& default_instance();

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

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

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

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

  FieldMeta* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FieldMeta>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FieldMeta& from);
  void MergeFrom(const FieldMeta& 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(FieldMeta* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.FieldMeta";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFieldNameFieldNumber = 1,
    kDimFieldNumber = 3,
    kTypeFieldNumber = 2,
  };
  // string field_name = 1;
  void clear_field_name();
  const std::string& field_name() const;
  void set_field_name(const std::string& value);
  void set_field_name(std::string&& value);
  void set_field_name(const char* value);
  void set_field_name(const char* value, size_t size);
  std::string* mutable_field_name();
  std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);

  // int64 dim = 3;
  void clear_dim();
  ::PROTOBUF_NAMESPACE_ID::int64 dim() const;
  void set_dim(::PROTOBUF_NAMESPACE_ID::int64 value);

  // .milvus.grpc.DataType type = 2;
  void clear_type();
  ::milvus::grpc::DataType type() const;
  void set_type(::milvus::grpc::DataType value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.FieldMeta)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_;
  ::PROTOBUF_NAMESPACE_ID::int64 dim_;
  int type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Schema :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Schema) */ {
 public:
  Schema();
  virtual ~Schema();

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

  inline Schema& operator=(const Schema& from) {
    CopyFrom(from);
    return *this;
  }
  inline Schema& operator=(Schema&& 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 Schema& default_instance();

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

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

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

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

  Schema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Schema>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Schema& from);
  void MergeFrom(const Schema& 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(Schema* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.Schema";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFieldMetasFieldNumber = 1,
  };
  // repeated .milvus.grpc.FieldMeta field_metas = 1;
  int field_metas_size() const;
  void clear_field_metas();
  ::milvus::grpc::FieldMeta* mutable_field_metas(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >*
      mutable_field_metas();
  const ::milvus::grpc::FieldMeta& field_metas(int index) const;
  ::milvus::grpc::FieldMeta* add_field_metas();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >&
      field_metas() const;

  // @@protoc_insertion_point(class_scope:milvus.grpc.Schema)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta > field_metas_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class RowData :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RowData) */ {
 public:
  RowData();
  virtual ~RowData();

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

  inline RowData& operator=(const RowData& from) {
    CopyFrom(from);
    return *this;
  }
  inline RowData& operator=(RowData&& 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 RowData& default_instance();

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

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

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

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

  RowData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RowData>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RowData& from);
  void MergeFrom(const RowData& 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(RowData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.RowData";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kBlobFieldNumber = 1,
  };
  // bytes blob = 1;
  void clear_blob();
  const std::string& blob() const;
  void set_blob(const std::string& value);
  void set_blob(std::string&& value);
  void set_blob(const char* value);
  void set_blob(const void* value, size_t size);
  std::string* mutable_blob();
  std::string* release_blob();
  void set_allocated_blob(std::string* blob);

  // @@protoc_insertion_point(class_scope:milvus.grpc.RowData)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class InsertParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.InsertParam) */ {
 public:
  InsertParam();
  virtual ~InsertParam();

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

  inline InsertParam& operator=(const InsertParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline InsertParam& operator=(InsertParam&& 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 InsertParam& default_instance();

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

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

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

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

  InsertParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InsertParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InsertParam& from);
  void MergeFrom(const InsertParam& 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(InsertParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.InsertParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRowsDataFieldNumber = 3,
    kEntityIdArrayFieldNumber = 4,
    kExtraParamsFieldNumber = 6,
    kCollectionNameFieldNumber = 1,
    kPartitionTagFieldNumber = 5,
    kSchemaFieldNumber = 2,
  };
  // repeated .milvus.grpc.RowData rows_data = 3;
  int rows_data_size() const;
  void clear_rows_data();
  ::milvus::grpc::RowData* mutable_rows_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >*
      mutable_rows_data();
  const ::milvus::grpc::RowData& rows_data(int index) const;
  ::milvus::grpc::RowData* add_rows_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >&
      rows_data() const;

  // repeated int64 entity_id_array = 4;
  int entity_id_array_size() const;
  void clear_entity_id_array();
  ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const;
  void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      entity_id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_entity_id_array();

  // repeated .milvus.grpc.KeyValuePair extra_params = 6;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // 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 = 5;
  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);

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.InsertParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData > rows_data_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_;
  mutable std::atomic<int> _entity_id_array_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_;
  ::milvus::grpc::Schema* schema_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class SearchParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchParam) */ {
 public:
  SearchParam();
  virtual ~SearchParam();

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

  inline SearchParam& operator=(const SearchParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchParam& operator=(SearchParam&& 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 SearchParam& default_instance();

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

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

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

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

  SearchParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SearchParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SearchParam& from);
  void MergeFrom(const SearchParam& 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(SearchParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.SearchParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kVectorParamFieldNumber = 2,
    kPartitionTagFieldNumber = 4,
    kExtraParamsFieldNumber = 5,
    kCollectionNameFieldNumber = 1,
    kDslFieldNumber = 3,
  };
  // repeated .milvus.grpc.VectorParam vector_param = 2;
  int vector_param_size() const;
  void clear_vector_param();
  ::milvus::grpc::VectorParam* mutable_vector_param(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >*
      mutable_vector_param();
  const ::milvus::grpc::VectorParam& vector_param(int index) const;
  ::milvus::grpc::VectorParam* add_vector_param();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >&
      vector_param() const;

  // repeated string partition_tag = 4;
  int partition_tag_size() const;
  void clear_partition_tag();
  const std::string& partition_tag(int index) const;
  std::string* mutable_partition_tag(int index);
  void set_partition_tag(int index, const std::string& value);
  void set_partition_tag(int index, std::string&& value);
  void set_partition_tag(int index, const char* value);
  void set_partition_tag(int index, const char* value, size_t size);
  std::string* add_partition_tag();
  void add_partition_tag(const std::string& value);
  void add_partition_tag(std::string&& value);
  void add_partition_tag(const char* value);
  void add_partition_tag(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tag() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tag();

  // repeated .milvus.grpc.KeyValuePair extra_params = 5;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // 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);

  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam > vector_param_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_tag_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class SearchInSegmentParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchInSegmentParam) */ {
 public:
  SearchInSegmentParam();
  virtual ~SearchInSegmentParam();

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

  inline SearchInSegmentParam& operator=(const SearchInSegmentParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchInSegmentParam& operator=(SearchInSegmentParam&& 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 SearchInSegmentParam& default_instance();

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

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

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

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

  SearchInSegmentParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SearchInSegmentParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SearchInSegmentParam& from);
  void MergeFrom(const SearchInSegmentParam& 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(SearchInSegmentParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.SearchInSegmentParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFileIdArrayFieldNumber = 1,
    kSearchParamFieldNumber = 2,
  };
  // repeated string file_id_array = 1;
  int file_id_array_size() const;
  void clear_file_id_array();
  const std::string& file_id_array(int index) const;
  std::string* mutable_file_id_array(int index);
  void set_file_id_array(int index, const std::string& value);
  void set_file_id_array(int index, std::string&& value);
  void set_file_id_array(int index, const char* value);
  void set_file_id_array(int index, const char* value, size_t size);
  std::string* add_file_id_array();
  void add_file_id_array(const std::string& value);
  void add_file_id_array(std::string&& value);
  void add_file_id_array(const char* value);
  void add_file_id_array(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& file_id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_file_id_array();

  // .milvus.grpc.SearchParam search_param = 2;
  bool has_search_param() const;
  void clear_search_param();
  const ::milvus::grpc::SearchParam& search_param() const;
  ::milvus::grpc::SearchParam* release_search_param();
  ::milvus::grpc::SearchParam* mutable_search_param();
  void set_allocated_search_param(::milvus::grpc::SearchParam* search_param);

  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchInSegmentParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_id_array_;
  ::milvus::grpc::SearchParam* search_param_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Entities :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Entities) */ {
 public:
  Entities();
  virtual ~Entities();

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

  inline Entities& operator=(const Entities& from) {
    CopyFrom(from);
    return *this;
  }
  inline Entities& operator=(Entities&& 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 Entities& default_instance();

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

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

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

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

  Entities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Entities>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Entities& from);
  void MergeFrom(const Entities& 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(Entities* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.Entities";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIdsFieldNumber = 2,
    kValidRowFieldNumber = 3,
    kRowsDataFieldNumber = 4,
    kStatusFieldNumber = 1,
  };
  // repeated int64 ids = 2;
  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 bool valid_row = 3;
  int valid_row_size() const;
  void clear_valid_row();
  bool valid_row(int index) const;
  void set_valid_row(int index, bool value);
  void add_valid_row(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      valid_row() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_valid_row();

  // repeated .milvus.grpc.RowData rows_data = 4;
  int rows_data_size() const;
  void clear_rows_data();
  ::milvus::grpc::RowData* mutable_rows_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >*
      mutable_rows_data();
  const ::milvus::grpc::RowData& rows_data(int index) const;
  ::milvus::grpc::RowData* add_rows_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >&
      rows_data() const;

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.Entities)
 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::RepeatedField< bool > valid_row_;
  mutable std::atomic<int> _valid_row_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData > rows_data_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class QueryResult :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.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 =
    20;

  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.grpc.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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kScoresFieldNumber = 4,
    kDistancesFieldNumber = 5,
    kExtraParamsFieldNumber = 6,
    kStatusFieldNumber = 1,
    kEntitiesFieldNumber = 2,
    kRowNumFieldNumber = 3,
    kQueryIdFieldNumber = 7,
    kClientIdFieldNumber = 8,
  };
  // repeated float scores = 4;
  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();

  // repeated float distances = 5;
  int distances_size() const;
  void clear_distances();
  float distances(int index) const;
  void set_distances(int index, float value);
  void add_distances(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      distances() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_distances();

  // repeated .milvus.grpc.KeyValuePair extra_params = 6;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

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

  // .milvus.grpc.Entities entities = 2;
  bool has_entities() const;
  void clear_entities();
  const ::milvus::grpc::Entities& entities() const;
  ::milvus::grpc::Entities* release_entities();
  ::milvus::grpc::Entities* mutable_entities();
  void set_allocated_entities(::milvus::grpc::Entities* entities);

  // int64 row_num = 3;
  void clear_row_num();
  ::PROTOBUF_NAMESPACE_ID::int64 row_num() const;
  void set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 query_id = 7;
  void clear_query_id();
  ::PROTOBUF_NAMESPACE_ID::int64 query_id() const;
  void set_query_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 client_id = 8;
  void clear_client_id();
  ::PROTOBUF_NAMESPACE_ID::int64 client_id() const;
  void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scores_;
  mutable std::atomic<int> _scores_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > distances_;
  mutable std::atomic<int> _distances_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::milvus::grpc::Status* status_;
  ::milvus::grpc::Entities* entities_;
  ::PROTOBUF_NAMESPACE_ID::int64 row_num_;
  ::PROTOBUF_NAMESPACE_ID::int64 query_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 client_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class StringReply :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.StringReply) */ {
 public:
  StringReply();
  virtual ~StringReply();

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

  inline StringReply& operator=(const StringReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringReply& operator=(StringReply&& 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 StringReply& default_instance();

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

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

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

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

  StringReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StringReply>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StringReply& from);
  void MergeFrom(const StringReply& 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(StringReply* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.StringReply";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStringReplyFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // string string_reply = 2;
  void clear_string_reply();
  const std::string& string_reply() const;
  void set_string_reply(const std::string& value);
  void set_string_reply(std::string&& value);
  void set_string_reply(const char* value);
  void set_string_reply(const char* value, size_t size);
  std::string* mutable_string_reply();
  std::string* release_string_reply();
  void set_allocated_string_reply(std::string* string_reply);

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.StringReply)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_reply_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class BoolReply :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BoolReply) */ {
 public:
  BoolReply();
  virtual ~BoolReply();

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

  inline BoolReply& operator=(const BoolReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolReply& operator=(BoolReply&& 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 BoolReply& default_instance();

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

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

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

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

  BoolReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BoolReply>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BoolReply& from);
  void MergeFrom(const BoolReply& 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(BoolReply* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.BoolReply";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

  // bool bool_reply = 2;
  void clear_bool_reply();
  bool bool_reply() const;
  void set_bool_reply(bool value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.BoolReply)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::grpc::Status* status_;
  bool bool_reply_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class CollectionRowCount :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionRowCount) */ {
 public:
  CollectionRowCount();
  virtual ~CollectionRowCount();

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

  inline CollectionRowCount& operator=(const CollectionRowCount& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollectionRowCount& operator=(CollectionRowCount&& 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 CollectionRowCount& default_instance();

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

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

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

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

  CollectionRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollectionRowCount>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollectionRowCount& from);
  void MergeFrom(const CollectionRowCount& 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(CollectionRowCount* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.CollectionRowCount";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

  // int64 collection_row_count = 2;
  void clear_collection_row_count();
  ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count() const;
  void set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionRowCount)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::grpc::Status* status_;
  ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Command :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Command) */ {
 public:
  Command();
  virtual ~Command();

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

  inline Command& operator=(const Command& from) {
    CopyFrom(from);
    return *this;
  }
  inline Command& operator=(Command&& 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 Command& default_instance();

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

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

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

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

  Command* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Command>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Command& from);
  void MergeFrom(const Command& 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(Command* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.Command";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCmdFieldNumber = 1,
  };
  // string cmd = 1;
  void clear_cmd();
  const std::string& cmd() const;
  void set_cmd(const std::string& value);
  void set_cmd(std::string&& value);
  void set_cmd(const char* value);
  void set_cmd(const char* value, size_t size);
  std::string* mutable_cmd();
  std::string* release_cmd();
  void set_allocated_cmd(std::string* cmd);

  // @@protoc_insertion_point(class_scope:milvus.grpc.Command)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cmd_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class IndexParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.IndexParam) */ {
 public:
  IndexParam();
  virtual ~IndexParam();

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

  inline IndexParam& operator=(const IndexParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline IndexParam& operator=(IndexParam&& 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 IndexParam& default_instance();

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

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

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

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

  IndexParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IndexParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IndexParam& from);
  void MergeFrom(const IndexParam& 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(IndexParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.IndexParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kExtraParamsFieldNumber = 5,
    kCollectionNameFieldNumber = 2,
    kFieldNameFieldNumber = 3,
    kIndexNameFieldNumber = 4,
    kStatusFieldNumber = 1,
  };
  // repeated .milvus.grpc.KeyValuePair extra_params = 5;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // string collection_name = 2;
  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 field_name = 3;
  void clear_field_name();
  const std::string& field_name() const;
  void set_field_name(const std::string& value);
  void set_field_name(std::string&& value);
  void set_field_name(const char* value);
  void set_field_name(const char* value, size_t size);
  std::string* mutable_field_name();
  std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);

  // string index_name = 4;
  void clear_index_name();
  const std::string& index_name() const;
  void set_index_name(const std::string& value);
  void set_index_name(std::string&& value);
  void set_index_name(const char* value);
  void set_index_name(const char* value, size_t size);
  std::string* mutable_index_name();
  std::string* release_index_name();
  void set_allocated_index_name(std::string* index_name);

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.IndexParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr index_name_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class FlushParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FlushParam) */ {
 public:
  FlushParam();
  virtual ~FlushParam();

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

  inline FlushParam& operator=(const FlushParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline FlushParam& operator=(FlushParam&& 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 FlushParam& default_instance();

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

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

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

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

  FlushParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FlushParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FlushParam& from);
  void MergeFrom(const FlushParam& 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(FlushParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.FlushParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNameArrayFieldNumber = 1,
  };
  // repeated string collection_name_array = 1;
  int collection_name_array_size() const;
  void clear_collection_name_array();
  const std::string& collection_name_array(int index) const;
  std::string* mutable_collection_name_array(int index);
  void set_collection_name_array(int index, const std::string& value);
  void set_collection_name_array(int index, std::string&& value);
  void set_collection_name_array(int index, const char* value);
  void set_collection_name_array(int index, const char* value, size_t size);
  std::string* add_collection_name_array();
  void add_collection_name_array(const std::string& value);
  void add_collection_name_array(std::string&& value);
  void add_collection_name_array(const char* value);
  void add_collection_name_array(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& collection_name_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_collection_name_array();

  // @@protoc_insertion_point(class_scope:milvus.grpc.FlushParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> collection_name_array_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class CompactParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CompactParam) */ {
 public:
  CompactParam();
  virtual ~CompactParam();

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

  inline CompactParam& operator=(const CompactParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompactParam& operator=(CompactParam&& 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 CompactParam& default_instance();

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

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

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

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

  CompactParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CompactParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CompactParam& from);
  void MergeFrom(const CompactParam& 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(CompactParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.CompactParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNameFieldNumber = 1,
    kThresholdFieldNumber = 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);

  // double threshold = 2;
  void clear_threshold();
  double threshold() const;
  void set_threshold(double value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.CompactParam)
 private:
  class _Internal;

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

class DeleteByIDParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.DeleteByIDParam) */ {
 public:
  DeleteByIDParam();
  virtual ~DeleteByIDParam();

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

  inline DeleteByIDParam& operator=(const DeleteByIDParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteByIDParam& operator=(DeleteByIDParam&& 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 DeleteByIDParam& default_instance();

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

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

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

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

  DeleteByIDParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeleteByIDParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeleteByIDParam& from);
  void MergeFrom(const DeleteByIDParam& 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(DeleteByIDParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.DeleteByIDParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIdArrayFieldNumber = 2,
    kCollectionNameFieldNumber = 1,
  };
  // repeated int64 id_array = 2;
  int id_array_size() const;
  void clear_id_array();
  ::PROTOBUF_NAMESPACE_ID::int64 id_array(int index) const;
  void set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_id_array();

  // 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.grpc.DeleteByIDParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_;
  mutable std::atomic<int> _id_array_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class CollectionInfo :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionInfo) */ {
 public:
  CollectionInfo();
  virtual ~CollectionInfo();

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

  inline CollectionInfo& operator=(const CollectionInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollectionInfo& operator=(CollectionInfo&& 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 CollectionInfo& default_instance();

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

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

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

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

  CollectionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollectionInfo>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollectionInfo& from);
  void MergeFrom(const CollectionInfo& 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(CollectionInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.CollectionInfo";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kJsonInfoFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // string json_info = 2;
  void clear_json_info();
  const std::string& json_info() const;
  void set_json_info(const std::string& value);
  void set_json_info(std::string&& value);
  void set_json_info(const char* value);
  void set_json_info(const char* value, size_t size);
  std::string* mutable_json_info();
  std::string* release_json_info();
  void set_allocated_json_info(std::string* json_info);

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionInfo)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_info_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class GetEntityIDsParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.GetEntityIDsParam) */ {
 public:
  GetEntityIDsParam();
  virtual ~GetEntityIDsParam();

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

  inline GetEntityIDsParam& operator=(const GetEntityIDsParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetEntityIDsParam& operator=(GetEntityIDsParam&& 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 GetEntityIDsParam& default_instance();

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

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

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

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

  GetEntityIDsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetEntityIDsParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetEntityIDsParam& from);
  void MergeFrom(const GetEntityIDsParam& 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(GetEntityIDsParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.GetEntityIDsParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNameFieldNumber = 1,
    kSegmentIdFieldNumber = 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);

  // int64 segment_id = 2;
  void clear_segment_id();
  ::PROTOBUF_NAMESPACE_ID::int64 segment_id() const;
  void set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.GetEntityIDsParam)
 private:
  class _Internal;

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

class EntityIdentity :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.EntityIdentity) */ {
 public:
  EntityIdentity();
  virtual ~EntityIdentity();

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

  inline EntityIdentity& operator=(const EntityIdentity& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntityIdentity& operator=(EntityIdentity&& 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 EntityIdentity& default_instance();

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

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

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

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

  EntityIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EntityIdentity>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const EntityIdentity& from);
  void MergeFrom(const EntityIdentity& 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(EntityIdentity* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.EntityIdentity";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIdArrayFieldNumber = 2,
    kFieldNamesFieldNumber = 3,
    kCollectionNameFieldNumber = 1,
  };
  // repeated int64 id_array = 2;
  int id_array_size() const;
  void clear_id_array();
  ::PROTOBUF_NAMESPACE_ID::int64 id_array(int index) const;
  void set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_id_array();

  // repeated string field_names = 3;
  int field_names_size() const;
  void clear_field_names();
  const std::string& field_names(int index) const;
  std::string* mutable_field_names(int index);
  void set_field_names(int index, const std::string& value);
  void set_field_names(int index, std::string&& value);
  void set_field_names(int index, const char* value);
  void set_field_names(int index, const char* value, size_t size);
  std::string* add_field_names();
  void add_field_names(const std::string& value);
  void add_field_names(std::string&& value);
  void add_field_names(const char* value);
  void add_field_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& field_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_field_names();

  // 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.grpc.EntityIdentity)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_;
  mutable std::atomic<int> _id_array_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> field_names_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class VectorFieldParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldParam) */ {
 public:
  VectorFieldParam();
  virtual ~VectorFieldParam();

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

  inline VectorFieldParam& operator=(const VectorFieldParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorFieldParam& operator=(VectorFieldParam&& 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 VectorFieldParam& default_instance();

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

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

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

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

  VectorFieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VectorFieldParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VectorFieldParam& from);
  void MergeFrom(const VectorFieldParam& 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(VectorFieldParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.VectorFieldParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDimensionFieldNumber = 1,
  };
  // int64 dimension = 1;
  void clear_dimension();
  ::PROTOBUF_NAMESPACE_ID::int64 dimension() const;
  void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int64 dimension_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class FieldType :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldType) */ {
 public:
  FieldType();
  virtual ~FieldType();

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

  inline FieldType& operator=(const FieldType& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldType& operator=(FieldType&& 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 FieldType& default_instance();

  enum ValueCase {
    kDataType = 1,
    kVectorParam = 2,
    VALUE_NOT_SET = 0,
  };

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

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

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

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

  FieldType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FieldType>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FieldType& from);
  void MergeFrom(const FieldType& 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(FieldType* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.FieldType";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataTypeFieldNumber = 1,
    kVectorParamFieldNumber = 2,
  };
  // .milvus.grpc.DataType data_type = 1;
  private:
  bool has_data_type() const;
  public:
  void clear_data_type();
  ::milvus::grpc::DataType data_type() const;
  void set_data_type(::milvus::grpc::DataType value);

  // .milvus.grpc.VectorFieldParam vector_param = 2;
  bool has_vector_param() const;
  void clear_vector_param();
  const ::milvus::grpc::VectorFieldParam& vector_param() const;
  ::milvus::grpc::VectorFieldParam* release_vector_param();
  ::milvus::grpc::VectorFieldParam* mutable_vector_param();
  void set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param);

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:milvus.grpc.FieldType)
 private:
  class _Internal;
  void set_has_data_type();
  void set_has_vector_param();

  inline bool has_value() const;
  inline void clear_has_value();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  union ValueUnion {
    ValueUnion() {}
    int data_type_;
    ::milvus::grpc::VectorFieldParam* vector_param_;
  } value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class FieldParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldParam) */ {
 public:
  FieldParam();
  virtual ~FieldParam();

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

  inline FieldParam& operator=(const FieldParam& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldParam& operator=(FieldParam&& 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 FieldParam& default_instance();

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

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

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

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

  FieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FieldParam>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FieldParam& from);
  void MergeFrom(const FieldParam& 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(FieldParam* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.FieldParam";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIndexParamsFieldNumber = 4,
    kExtraParamsFieldNumber = 5,
    kNameFieldNumber = 2,
    kIdFieldNumber = 1,
    kTypeFieldNumber = 3,
  };
  // repeated .milvus.grpc.KeyValuePair index_params = 4;
  int index_params_size() const;
  void clear_index_params();
  ::milvus::grpc::KeyValuePair* mutable_index_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_index_params();
  const ::milvus::grpc::KeyValuePair& index_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_index_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      index_params() const;

  // repeated .milvus.grpc.KeyValuePair extra_params = 5;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // string name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // uint64 id = 1;
  void clear_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // .milvus.grpc.DataType type = 3;
  void clear_type();
  ::milvus::grpc::DataType type() const;
  void set_type(::milvus::grpc::DataType value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.FieldParam)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > index_params_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::uint64 id_;
  int type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class VectorFieldRecord :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldRecord) */ {
 public:
  VectorFieldRecord();
  virtual ~VectorFieldRecord();

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

  inline VectorFieldRecord& operator=(const VectorFieldRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorFieldRecord& operator=(VectorFieldRecord&& 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 VectorFieldRecord& default_instance();

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

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

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

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

  VectorFieldRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VectorFieldRecord>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VectorFieldRecord& from);
  void MergeFrom(const VectorFieldRecord& 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(VectorFieldRecord* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.VectorFieldRecord";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated .milvus.grpc.VectorRowRecord value = 1;
  int value_size() const;
  void clear_value();
  ::milvus::grpc::VectorRowRecord* mutable_value(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >*
      mutable_value();
  const ::milvus::grpc::VectorRowRecord& value(int index) const;
  ::milvus::grpc::VectorRowRecord* add_value();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >&
      value() const;

  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldRecord)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord > value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class TermQuery :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TermQuery) */ {
 public:
  TermQuery();
  virtual ~TermQuery();

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

  inline TermQuery& operator=(const TermQuery& from) {
    CopyFrom(from);
    return *this;
  }
  inline TermQuery& operator=(TermQuery&& 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 TermQuery& default_instance();

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

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

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

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

  TermQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TermQuery>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TermQuery& from);
  void MergeFrom(const TermQuery& 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(TermQuery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.TermQuery";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIntValueFieldNumber = 2,
    kDoubleValueFieldNumber = 3,
    kExtraParamsFieldNumber = 6,
    kFieldNameFieldNumber = 1,
    kValueNumFieldNumber = 4,
    kBoostFieldNumber = 5,
  };
  // repeated int64 int_value = 2;
  int int_value_size() const;
  void clear_int_value();
  ::PROTOBUF_NAMESPACE_ID::int64 int_value(int index) const;
  void set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      int_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_int_value();

  // repeated double double_value = 3;
  int double_value_size() const;
  void clear_double_value();
  double double_value(int index) const;
  void set_double_value(int index, double value);
  void add_double_value(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      double_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_double_value();

  // repeated .milvus.grpc.KeyValuePair extra_params = 6;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // string field_name = 1;
  void clear_field_name();
  const std::string& field_name() const;
  void set_field_name(const std::string& value);
  void set_field_name(std::string&& value);
  void set_field_name(const char* value);
  void set_field_name(const char* value, size_t size);
  std::string* mutable_field_name();
  std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);

  // int64 value_num = 4;
  void clear_value_num();
  ::PROTOBUF_NAMESPACE_ID::int64 value_num() const;
  void set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value);

  // float boost = 5;
  void clear_boost();
  float boost() const;
  void set_boost(float value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.TermQuery)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int_value_;
  mutable std::atomic<int> _int_value_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_;
  mutable std::atomic<int> _double_value_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_;
  ::PROTOBUF_NAMESPACE_ID::int64 value_num_;
  float boost_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class CompareExpr :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CompareExpr) */ {
 public:
  CompareExpr();
  virtual ~CompareExpr();

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

  inline CompareExpr& operator=(const CompareExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompareExpr& operator=(CompareExpr&& 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 CompareExpr& default_instance();

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

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

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

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

  CompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CompareExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CompareExpr& from);
  void MergeFrom(const CompareExpr& 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(CompareExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.CompareExpr";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOperandFieldNumber = 2,
    kOperatorFieldNumber = 1,
  };
  // string operand = 2;
  void clear_operand();
  const std::string& operand() const;
  void set_operand(const std::string& value);
  void set_operand(std::string&& value);
  void set_operand(const char* value);
  void set_operand(const char* value, size_t size);
  std::string* mutable_operand();
  std::string* release_operand();
  void set_allocated_operand(std::string* operand);

  // .milvus.grpc.CompareOperator operator = 1;
  void clear_operator_();
  ::milvus::grpc::CompareOperator operator_() const;
  void set_operator_(::milvus::grpc::CompareOperator value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.CompareExpr)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operand_;
  int operator__;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class RangeQuery :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RangeQuery) */ {
 public:
  RangeQuery();
  virtual ~RangeQuery();

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

  inline RangeQuery& operator=(const RangeQuery& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeQuery& operator=(RangeQuery&& 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 RangeQuery& default_instance();

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

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

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

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

  RangeQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeQuery>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeQuery& from);
  void MergeFrom(const RangeQuery& 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(RangeQuery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.RangeQuery";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOperandFieldNumber = 2,
    kExtraParamsFieldNumber = 4,
    kFieldNameFieldNumber = 1,
    kBoostFieldNumber = 3,
  };
  // repeated .milvus.grpc.CompareExpr operand = 2;
  int operand_size() const;
  void clear_operand();
  ::milvus::grpc::CompareExpr* mutable_operand(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >*
      mutable_operand();
  const ::milvus::grpc::CompareExpr& operand(int index) const;
  ::milvus::grpc::CompareExpr* add_operand();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >&
      operand() const;

  // repeated .milvus.grpc.KeyValuePair extra_params = 4;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // string field_name = 1;
  void clear_field_name();
  const std::string& field_name() const;
  void set_field_name(const std::string& value);
  void set_field_name(std::string&& value);
  void set_field_name(const char* value);
  void set_field_name(const char* value, size_t size);
  std::string* mutable_field_name();
  std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);

  // float boost = 3;
  void clear_boost();
  float boost() const;
  void set_boost(float value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.RangeQuery)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr > operand_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_;
  float boost_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class VectorQuery :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorQuery) */ {
 public:
  VectorQuery();
  virtual ~VectorQuery();

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

  inline VectorQuery& operator=(const VectorQuery& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorQuery& operator=(VectorQuery&& 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 VectorQuery& default_instance();

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

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

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

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

  VectorQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VectorQuery>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VectorQuery& from);
  void MergeFrom(const VectorQuery& 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(VectorQuery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.VectorQuery";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRecordsFieldNumber = 3,
    kExtraParamsFieldNumber = 5,
    kFieldNameFieldNumber = 1,
    kTopkFieldNumber = 4,
    kQueryBoostFieldNumber = 2,
  };
  // repeated .milvus.grpc.VectorRowRecord records = 3;
  int records_size() const;
  void clear_records();
  ::milvus::grpc::VectorRowRecord* mutable_records(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >*
      mutable_records();
  const ::milvus::grpc::VectorRowRecord& records(int index) const;
  ::milvus::grpc::VectorRowRecord* add_records();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >&
      records() const;

  // repeated .milvus.grpc.KeyValuePair extra_params = 5;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // string field_name = 1;
  void clear_field_name();
  const std::string& field_name() const;
  void set_field_name(const std::string& value);
  void set_field_name(std::string&& value);
  void set_field_name(const char* value);
  void set_field_name(const char* value, size_t size);
  std::string* mutable_field_name();
  std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);

  // int64 topk = 4;
  void clear_topk();
  ::PROTOBUF_NAMESPACE_ID::int64 topk() const;
  void set_topk(::PROTOBUF_NAMESPACE_ID::int64 value);

  // float query_boost = 2;
  void clear_query_boost();
  float query_boost() const;
  void set_query_boost(float value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorQuery)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord > records_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_;
  ::PROTOBUF_NAMESPACE_ID::int64 topk_;
  float query_boost_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class BooleanQuery :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BooleanQuery) */ {
 public:
  BooleanQuery();
  virtual ~BooleanQuery();

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

  inline BooleanQuery& operator=(const BooleanQuery& from) {
    CopyFrom(from);
    return *this;
  }
  inline BooleanQuery& operator=(BooleanQuery&& 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 BooleanQuery& default_instance();

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

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

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

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

  BooleanQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BooleanQuery>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BooleanQuery& from);
  void MergeFrom(const BooleanQuery& 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(BooleanQuery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.BooleanQuery";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kGeneralQueryFieldNumber = 2,
    kOccurFieldNumber = 1,
  };
  // repeated .milvus.grpc.GeneralQuery general_query = 2;
  int general_query_size() const;
  void clear_general_query();
  ::milvus::grpc::GeneralQuery* mutable_general_query(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >*
      mutable_general_query();
  const ::milvus::grpc::GeneralQuery& general_query(int index) const;
  ::milvus::grpc::GeneralQuery* add_general_query();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >&
      general_query() const;

  // .milvus.grpc.Occur occur = 1;
  void clear_occur();
  ::milvus::grpc::Occur occur() const;
  void set_occur(::milvus::grpc::Occur value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.BooleanQuery)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery > general_query_;
  int occur_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class GeneralQuery :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.GeneralQuery) */ {
 public:
  GeneralQuery();
  virtual ~GeneralQuery();

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

  inline GeneralQuery& operator=(const GeneralQuery& from) {
    CopyFrom(from);
    return *this;
  }
  inline GeneralQuery& operator=(GeneralQuery&& 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 GeneralQuery& default_instance();

  enum QueryCase {
    kBooleanQuery = 1,
    kTermQuery = 2,
    kRangeQuery = 3,
    kVectorQuery = 4,
    QUERY_NOT_SET = 0,
  };

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

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

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

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

  GeneralQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GeneralQuery>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GeneralQuery& from);
  void MergeFrom(const GeneralQuery& 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(GeneralQuery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.GeneralQuery";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kBooleanQueryFieldNumber = 1,
    kTermQueryFieldNumber = 2,
    kRangeQueryFieldNumber = 3,
    kVectorQueryFieldNumber = 4,
  };
  // .milvus.grpc.BooleanQuery boolean_query = 1;
  bool has_boolean_query() const;
  void clear_boolean_query();
  const ::milvus::grpc::BooleanQuery& boolean_query() const;
  ::milvus::grpc::BooleanQuery* release_boolean_query();
  ::milvus::grpc::BooleanQuery* mutable_boolean_query();
  void set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query);

  // .milvus.grpc.TermQuery term_query = 2;
  bool has_term_query() const;
  void clear_term_query();
  const ::milvus::grpc::TermQuery& term_query() const;
  ::milvus::grpc::TermQuery* release_term_query();
  ::milvus::grpc::TermQuery* mutable_term_query();
  void set_allocated_term_query(::milvus::grpc::TermQuery* term_query);

  // .milvus.grpc.RangeQuery range_query = 3;
  bool has_range_query() const;
  void clear_range_query();
  const ::milvus::grpc::RangeQuery& range_query() const;
  ::milvus::grpc::RangeQuery* release_range_query();
  ::milvus::grpc::RangeQuery* mutable_range_query();
  void set_allocated_range_query(::milvus::grpc::RangeQuery* range_query);

  // .milvus.grpc.VectorQuery vector_query = 4;
  bool has_vector_query() const;
  void clear_vector_query();
  const ::milvus::grpc::VectorQuery& vector_query() const;
  ::milvus::grpc::VectorQuery* release_vector_query();
  ::milvus::grpc::VectorQuery* mutable_vector_query();
  void set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query);

  void clear_query();
  QueryCase query_case() const;
  // @@protoc_insertion_point(class_scope:milvus.grpc.GeneralQuery)
 private:
  class _Internal;
  void set_has_boolean_query();
  void set_has_term_query();
  void set_has_range_query();
  void set_has_vector_query();

  inline bool has_query() const;
  inline void clear_has_query();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  union QueryUnion {
    QueryUnion() {}
    ::milvus::grpc::BooleanQuery* boolean_query_;
    ::milvus::grpc::TermQuery* term_query_;
    ::milvus::grpc::RangeQuery* range_query_;
    ::milvus::grpc::VectorQuery* vector_query_;
  } query_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class SearchParamPB :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchParamPB) */ {
 public:
  SearchParamPB();
  virtual ~SearchParamPB();

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

  inline SearchParamPB& operator=(const SearchParamPB& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchParamPB& operator=(SearchParamPB&& 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 SearchParamPB& default_instance();

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

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

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

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

  SearchParamPB* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SearchParamPB>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SearchParamPB& from);
  void MergeFrom(const SearchParamPB& 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(SearchParamPB* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.SearchParamPB";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPartitionTagArrayFieldNumber = 2,
    kExtraParamsFieldNumber = 4,
    kCollectionNameFieldNumber = 1,
    kGeneralQueryFieldNumber = 3,
  };
  // repeated string partition_tag_array = 2;
  int partition_tag_array_size() const;
  void clear_partition_tag_array();
  const std::string& partition_tag_array(int index) const;
  std::string* mutable_partition_tag_array(int index);
  void set_partition_tag_array(int index, const std::string& value);
  void set_partition_tag_array(int index, std::string&& value);
  void set_partition_tag_array(int index, const char* value);
  void set_partition_tag_array(int index, const char* value, size_t size);
  std::string* add_partition_tag_array();
  void add_partition_tag_array(const std::string& value);
  void add_partition_tag_array(std::string&& value);
  void add_partition_tag_array(const char* value);
  void add_partition_tag_array(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tag_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tag_array();

  // repeated .milvus.grpc.KeyValuePair extra_params = 4;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // 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);

  // .milvus.grpc.GeneralQuery general_query = 3;
  bool has_general_query() const;
  void clear_general_query();
  const ::milvus::grpc::GeneralQuery& general_query() const;
  ::milvus::grpc::GeneralQuery* release_general_query();
  ::milvus::grpc::GeneralQuery* mutable_general_query();
  void set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query);

  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchParamPB)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_tag_array_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::milvus::grpc::GeneralQuery* general_query_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class InsertOrDeleteMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.InsertOrDeleteMsg) */ {
 public:
  InsertOrDeleteMsg();
  virtual ~InsertOrDeleteMsg();

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

  inline InsertOrDeleteMsg& operator=(const InsertOrDeleteMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline InsertOrDeleteMsg& operator=(InsertOrDeleteMsg&& 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 InsertOrDeleteMsg& default_instance();

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

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

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

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

  InsertOrDeleteMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InsertOrDeleteMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InsertOrDeleteMsg& from);
  void MergeFrom(const InsertOrDeleteMsg& 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(InsertOrDeleteMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.InsertOrDeleteMsg";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kExtraParamsFieldNumber = 10,
    kCollectionNameFieldNumber = 1,
    kPartitionTagFieldNumber = 4,
    kRowsDataFieldNumber = 2,
    kUidFieldNumber = 3,
    kTimestampFieldNumber = 5,
    kSegmentIdFieldNumber = 6,
    kChannelIdFieldNumber = 7,
    kClientIdFieldNumber = 9,
    kOpFieldNumber = 8,
  };
  // repeated .milvus.grpc.KeyValuePair extra_params = 10;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // 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 = 4;
  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);

  // .milvus.grpc.RowData rows_data = 2;
  bool has_rows_data() const;
  void clear_rows_data();
  const ::milvus::grpc::RowData& rows_data() const;
  ::milvus::grpc::RowData* release_rows_data();
  ::milvus::grpc::RowData* mutable_rows_data();
  void set_allocated_rows_data(::milvus::grpc::RowData* rows_data);

  // int64 uid = 3;
  void clear_uid();
  ::PROTOBUF_NAMESPACE_ID::int64 uid() const;
  void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint64 timestamp = 5;
  void clear_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
  void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int64 segment_id = 6;
  void clear_segment_id();
  ::PROTOBUF_NAMESPACE_ID::int64 segment_id() const;
  void set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 channel_id = 7;
  void clear_channel_id();
  ::PROTOBUF_NAMESPACE_ID::int64 channel_id() const;
  void set_channel_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 client_id = 9;
  void clear_client_id();
  ::PROTOBUF_NAMESPACE_ID::int64 client_id() const;
  void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // .milvus.grpc.OpType op = 8;
  void clear_op();
  ::milvus::grpc::OpType op() const;
  void set_op(::milvus::grpc::OpType value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.InsertOrDeleteMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_;
  ::milvus::grpc::RowData* rows_data_;
  ::PROTOBUF_NAMESPACE_ID::int64 uid_;
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
  ::PROTOBUF_NAMESPACE_ID::int64 segment_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 channel_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 client_id_;
  int op_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class SearchMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchMsg) */ {
 public:
  SearchMsg();
  virtual ~SearchMsg();

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

  inline SearchMsg& operator=(const SearchMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchMsg& operator=(SearchMsg&& 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 SearchMsg& default_instance();

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

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

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

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

  SearchMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SearchMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SearchMsg& from);
  void MergeFrom(const SearchMsg& 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(SearchMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.SearchMsg";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPartitionTagFieldNumber = 3,
    kExtraParamsFieldNumber = 7,
    kJsonFieldNumber = 8,
    kCollectionNameFieldNumber = 1,
    kDslFieldNumber = 9,
    kRecordsFieldNumber = 2,
    kUidFieldNumber = 4,
    kTimestampFieldNumber = 5,
    kClientIdFieldNumber = 6,
  };
  // repeated string partition_tag = 3;
  int partition_tag_size() const;
  void clear_partition_tag();
  const std::string& partition_tag(int index) const;
  std::string* mutable_partition_tag(int index);
  void set_partition_tag(int index, const std::string& value);
  void set_partition_tag(int index, std::string&& value);
  void set_partition_tag(int index, const char* value);
  void set_partition_tag(int index, const char* value, size_t size);
  std::string* add_partition_tag();
  void add_partition_tag(const std::string& value);
  void add_partition_tag(std::string&& value);
  void add_partition_tag(const char* value);
  void add_partition_tag(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tag() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tag();

  // repeated .milvus.grpc.KeyValuePair extra_params = 7;
  int extra_params_size() const;
  void clear_extra_params();
  ::milvus::grpc::KeyValuePair* mutable_extra_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
      mutable_extra_params();
  const ::milvus::grpc::KeyValuePair& extra_params(int index) const;
  ::milvus::grpc::KeyValuePair* add_extra_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
      extra_params() const;

  // repeated string json = 8;
  int json_size() const;
  void clear_json();
  const std::string& json(int index) const;
  std::string* mutable_json(int index);
  void set_json(int index, const std::string& value);
  void set_json(int index, std::string&& value);
  void set_json(int index, const char* value);
  void set_json(int index, const char* value, size_t size);
  std::string* add_json();
  void add_json(const std::string& value);
  void add_json(std::string&& value);
  void add_json(const char* value);
  void add_json(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& json() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_json();

  // 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 = 9;
  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);

  // .milvus.grpc.VectorRowRecord records = 2;
  bool has_records() const;
  void clear_records();
  const ::milvus::grpc::VectorRowRecord& records() const;
  ::milvus::grpc::VectorRowRecord* release_records();
  ::milvus::grpc::VectorRowRecord* mutable_records();
  void set_allocated_records(::milvus::grpc::VectorRowRecord* records);

  // int64 uid = 4;
  void clear_uid();
  ::PROTOBUF_NAMESPACE_ID::int64 uid() const;
  void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint64 timestamp = 5;
  void clear_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
  void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int64 client_id = 6;
  void clear_client_id();
  ::PROTOBUF_NAMESPACE_ID::int64 client_id() const;
  void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_tag_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> json_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_;
  ::milvus::grpc::VectorRowRecord* records_;
  ::PROTOBUF_NAMESPACE_ID::int64 uid_;
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
  ::PROTOBUF_NAMESPACE_ID::int64 client_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class TimeSyncMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TimeSyncMsg) */ {
 public:
  TimeSyncMsg();
  virtual ~TimeSyncMsg();

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

  inline TimeSyncMsg& operator=(const TimeSyncMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline TimeSyncMsg& operator=(TimeSyncMsg&& 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 TimeSyncMsg& default_instance();

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

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

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

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

  TimeSyncMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TimeSyncMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TimeSyncMsg& from);
  void MergeFrom(const TimeSyncMsg& 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(TimeSyncMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.TimeSyncMsg";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPeerIdFieldNumber = 1,
    kTimestampFieldNumber = 2,
    kSyncTypeFieldNumber = 3,
  };
  // int64 peer_Id = 1;
  void clear_peer_id();
  ::PROTOBUF_NAMESPACE_ID::int64 peer_id() const;
  void set_peer_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint64 Timestamp = 2;
  void clear_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
  void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // .milvus.grpc.SyncType sync_type = 3;
  void clear_sync_type();
  ::milvus::grpc::SyncType sync_type() const;
  void set_sync_type(::milvus::grpc::SyncType value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.TimeSyncMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int64 peer_id_;
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
  int sync_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Key2SegMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Key2SegMsg) */ {
 public:
  Key2SegMsg();
  virtual ~Key2SegMsg();

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

  inline Key2SegMsg& operator=(const Key2SegMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline Key2SegMsg& operator=(Key2SegMsg&& 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 Key2SegMsg& default_instance();

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

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

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

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

  Key2SegMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Key2SegMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Key2SegMsg& from);
  void MergeFrom(const Key2SegMsg& 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(Key2SegMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.grpc.Key2SegMsg";
  }
  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_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSegmentIdFieldNumber = 3,
    kUidFieldNumber = 1,
    kTimestampFieldNumber = 2,
  };
  // repeated int64 segment_id = 3;
  int segment_id_size() const;
  void clear_segment_id();
  ::PROTOBUF_NAMESPACE_ID::int64 segment_id(int index) const;
  void set_segment_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      segment_id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_segment_id();

  // int64 uid = 1;
  void clear_uid();
  ::PROTOBUF_NAMESPACE_ID::int64 uid() const;
  void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint64 timestamp = 2;
  void clear_timestamp();
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
  void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.Key2SegMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > segment_id_;
  mutable std::atomic<int> _segment_id_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::int64 uid_;
  ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// ===================================================================


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

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

// .milvus.grpc.ErrorCode error_code = 1;
inline void Status::clear_error_code() {
  error_code_ = 0;
}
inline ::milvus::grpc::ErrorCode Status::error_code() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Status.error_code)
  return static_cast< ::milvus::grpc::ErrorCode >(error_code_);
}
inline void Status::set_error_code(::milvus::grpc::ErrorCode value) {
  
  error_code_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.Status.error_code)
}

// string reason = 2;
inline void Status::clear_reason() {
  reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Status::reason() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Status.reason)
  return reason_.GetNoArena();
}
inline void Status::set_reason(const std::string& value) {
  
  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Status.reason)
}
inline void Status::set_reason(std::string&& value) {
  
  reason_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Status.reason)
}
inline void Status::set_reason(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.Status.reason)
}
inline void Status::set_reason(const char* value, size_t size) {
  
  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Status.reason)
}
inline std::string* Status::mutable_reason() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Status.reason)
  return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Status::release_reason() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Status.reason)
  
  return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Status::set_allocated_reason(std::string* reason) {
  if (reason != nullptr) {
    
  } else {
    
  }
  reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Status.reason)
}

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

// KeyValuePair

// string key = 1;
inline void KeyValuePair::clear_key() {
  key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValuePair::key() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.KeyValuePair.key)
  return key_.GetNoArena();
}
inline void KeyValuePair::set_key(const std::string& value) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.KeyValuePair.key)
}
inline void KeyValuePair::set_key(std::string&& value) {
  
  key_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.KeyValuePair.key)
}
inline void KeyValuePair::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.KeyValuePair.key)
}
inline void KeyValuePair::set_key(const char* value, size_t size) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.KeyValuePair.key)
}
inline std::string* KeyValuePair::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.KeyValuePair.key)
  return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValuePair::release_key() {
  // @@protoc_insertion_point(field_release:milvus.grpc.KeyValuePair.key)
  
  return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValuePair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.KeyValuePair.key)
}

// string value = 2;
inline void KeyValuePair::clear_value() {
  value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValuePair::value() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.KeyValuePair.value)
  return value_.GetNoArena();
}
inline void KeyValuePair::set_value(const std::string& value) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.KeyValuePair.value)
}
inline void KeyValuePair::set_value(std::string&& value) {
  
  value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.KeyValuePair.value)
}
inline void KeyValuePair::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.grpc.KeyValuePair.value)
}
inline void KeyValuePair::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.grpc.KeyValuePair.value)
}
inline std::string* KeyValuePair::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.KeyValuePair.value)
  return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValuePair::release_value() {
  // @@protoc_insertion_point(field_release:milvus.grpc.KeyValuePair.value)
  
  return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValuePair::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.grpc.KeyValuePair.value)
}

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

// 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.grpc.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.grpc.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.grpc.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.grpc.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.grpc.CollectionName.collection_name)
}
inline std::string* CollectionName::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.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.grpc.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.grpc.CollectionName.collection_name)
}

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

// CollectionNameList

// .milvus.grpc.Status status = 1;
inline bool CollectionNameList::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void CollectionNameList::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& CollectionNameList::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* CollectionNameList::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.CollectionNameList.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* CollectionNameList::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.status)
  return status_;
}
inline void CollectionNameList::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.CollectionNameList.status)
}

// repeated string collection_names = 2;
inline int CollectionNameList::collection_names_size() const {
  return collection_names_.size();
}
inline void CollectionNameList::clear_collection_names() {
  collection_names_.Clear();
}
inline const std::string& CollectionNameList::collection_names(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.collection_names)
  return collection_names_.Get(index);
}
inline std::string* CollectionNameList::mutable_collection_names(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.collection_names)
  return collection_names_.Mutable(index);
}
inline void CollectionNameList::set_collection_names(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names)
  collection_names_.Mutable(index)->assign(value);
}
inline void CollectionNameList::set_collection_names(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names)
  collection_names_.Mutable(index)->assign(std::move(value));
}
inline void CollectionNameList::set_collection_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  collection_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionNameList.collection_names)
}
inline void CollectionNameList::set_collection_names(int index, const char* value, size_t size) {
  collection_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionNameList.collection_names)
}
inline std::string* CollectionNameList::add_collection_names() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.CollectionNameList.collection_names)
  return collection_names_.Add();
}
inline void CollectionNameList::add_collection_names(const std::string& value) {
  collection_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names)
}
inline void CollectionNameList::add_collection_names(std::string&& value) {
  collection_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names)
}
inline void CollectionNameList::add_collection_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  collection_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.CollectionNameList.collection_names)
}
inline void CollectionNameList::add_collection_names(const char* value, size_t size) {
  collection_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.CollectionNameList.collection_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CollectionNameList::collection_names() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.CollectionNameList.collection_names)
  return collection_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CollectionNameList::mutable_collection_names() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionNameList.collection_names)
  return &collection_names_;
}

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

// FieldName

// string collection_name = 1;
inline void FieldName::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& FieldName::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldName.collection_name)
  return collection_name_.GetNoArena();
}
inline void FieldName::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldName.collection_name)
}
inline void FieldName::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldName.collection_name)
}
inline void FieldName::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.grpc.FieldName.collection_name)
}
inline void FieldName::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.grpc.FieldName.collection_name)
}
inline std::string* FieldName::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldName.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* FieldName::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.FieldName.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void FieldName::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.grpc.FieldName.collection_name)
}

// string field_name = 2;
inline void FieldName::clear_field_name() {
  field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& FieldName::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldName.field_name)
  return field_name_.GetNoArena();
}
inline void FieldName::set_field_name(const std::string& value) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldName.field_name)
}
inline void FieldName::set_field_name(std::string&& value) {
  
  field_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldName.field_name)
}
inline void FieldName::set_field_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldName.field_name)
}
inline void FieldName::set_field_name(const char* value, size_t size) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldName.field_name)
}
inline std::string* FieldName::mutable_field_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldName.field_name)
  return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* FieldName::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.FieldName.field_name)
  
  return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void FieldName::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldName.field_name)
}

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

// Mapping

// .milvus.grpc.Status status = 1;
inline bool Mapping::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void Mapping::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& Mapping::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* Mapping::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* Mapping::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.status)
  return status_;
}
inline void Mapping::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.Mapping.status)
}

// string collection_name = 2;
inline void Mapping::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Mapping::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.collection_name)
  return collection_name_.GetNoArena();
}
inline void Mapping::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Mapping.collection_name)
}
inline void Mapping::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Mapping.collection_name)
}
inline void Mapping::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.grpc.Mapping.collection_name)
}
inline void Mapping::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.grpc.Mapping.collection_name)
}
inline std::string* Mapping::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Mapping::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Mapping::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.grpc.Mapping.collection_name)
}

// .milvus.grpc.Schema schema = 3;
inline bool Mapping::has_schema() const {
  return this != internal_default_instance() && schema_ != nullptr;
}
inline void Mapping::clear_schema() {
  if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) {
    delete schema_;
  }
  schema_ = nullptr;
}
inline const ::milvus::grpc::Schema& Mapping::schema() const {
  const ::milvus::grpc::Schema* p = schema_;
  // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.schema)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Schema*>(
      &::milvus::grpc::_Schema_default_instance_);
}
inline ::milvus::grpc::Schema* Mapping::release_schema() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.schema)
  
  ::milvus::grpc::Schema* temp = schema_;
  schema_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Schema* Mapping::mutable_schema() {
  
  if (schema_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Schema>(GetArenaNoVirtual());
    schema_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.schema)
  return schema_;
}
inline void Mapping::set_allocated_schema(::milvus::grpc::Schema* schema) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.Mapping.schema)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 4;
inline int Mapping::extra_params_size() const {
  return extra_params_.size();
}
inline void Mapping::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* Mapping::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
Mapping::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Mapping.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& Mapping::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* Mapping::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.Mapping.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
Mapping::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.Mapping.extra_params)
  return extra_params_;
}

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

// MappingList

// .milvus.grpc.Status status = 1;
inline bool MappingList::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void MappingList::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& MappingList::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* MappingList::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.MappingList.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* MappingList::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.status)
  return status_;
}
inline void MappingList::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.MappingList.status)
}

// repeated .milvus.grpc.Mapping mapping_list = 2;
inline int MappingList::mapping_list_size() const {
  return mapping_list_.size();
}
inline void MappingList::clear_mapping_list() {
  mapping_list_.Clear();
}
inline ::milvus::grpc::Mapping* MappingList::mutable_mapping_list(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.mapping_list)
  return mapping_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >*
MappingList::mutable_mapping_list() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.MappingList.mapping_list)
  return &mapping_list_;
}
inline const ::milvus::grpc::Mapping& MappingList::mapping_list(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.mapping_list)
  return mapping_list_.Get(index);
}
inline ::milvus::grpc::Mapping* MappingList::add_mapping_list() {
  // @@protoc_insertion_point(field_add:milvus.grpc.MappingList.mapping_list)
  return mapping_list_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >&
MappingList::mapping_list() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.MappingList.mapping_list)
  return mapping_list_;
}

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

// PartitionParam

// string collection_name = 1;
inline void PartitionParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void PartitionParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.collection_name)
}
inline void PartitionParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.collection_name)
}
inline void PartitionParam::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.grpc.PartitionParam.collection_name)
}
inline void PartitionParam::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.grpc.PartitionParam.collection_name)
}
inline std::string* PartitionParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionParam::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.grpc.PartitionParam.collection_name)
}

// string tag = 2;
inline void PartitionParam::clear_tag() {
  tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionParam::tag() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.tag)
  return tag_.GetNoArena();
}
inline void PartitionParam::set_tag(const std::string& value) {
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.tag)
}
inline void PartitionParam::set_tag(std::string&& value) {
  
  tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.tag)
}
inline void PartitionParam::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.grpc.PartitionParam.tag)
}
inline void PartitionParam::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.grpc.PartitionParam.tag)
}
inline std::string* PartitionParam::mutable_tag() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.tag)
  return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionParam::release_tag() {
  // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.tag)
  
  return tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionParam::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.grpc.PartitionParam.tag)
}

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

// PartitionList

// .milvus.grpc.Status status = 1;
inline bool PartitionList::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void PartitionList::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& PartitionList::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionList.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* PartitionList::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.PartitionList.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* PartitionList::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionList.status)
  return status_;
}
inline void PartitionList::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.PartitionList.status)
}

// repeated string partition_tag_array = 2;
inline int PartitionList::partition_tag_array_size() const {
  return partition_tag_array_.size();
}
inline void PartitionList::clear_partition_tag_array() {
  partition_tag_array_.Clear();
}
inline const std::string& PartitionList::partition_tag_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionList.partition_tag_array)
  return partition_tag_array_.Get(index);
}
inline std::string* PartitionList::mutable_partition_tag_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionList.partition_tag_array)
  return partition_tag_array_.Mutable(index);
}
inline void PartitionList::set_partition_tag_array(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionList.partition_tag_array)
  partition_tag_array_.Mutable(index)->assign(value);
}
inline void PartitionList::set_partition_tag_array(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionList.partition_tag_array)
  partition_tag_array_.Mutable(index)->assign(std::move(value));
}
inline void PartitionList::set_partition_tag_array(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_array_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionList.partition_tag_array)
}
inline void PartitionList::set_partition_tag_array(int index, const char* value, size_t size) {
  partition_tag_array_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionList.partition_tag_array)
}
inline std::string* PartitionList::add_partition_tag_array() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.PartitionList.partition_tag_array)
  return partition_tag_array_.Add();
}
inline void PartitionList::add_partition_tag_array(const std::string& value) {
  partition_tag_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.PartitionList.partition_tag_array)
}
inline void PartitionList::add_partition_tag_array(std::string&& value) {
  partition_tag_array_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.PartitionList.partition_tag_array)
}
inline void PartitionList::add_partition_tag_array(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.PartitionList.partition_tag_array)
}
inline void PartitionList::add_partition_tag_array(const char* value, size_t size) {
  partition_tag_array_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.PartitionList.partition_tag_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PartitionList::partition_tag_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.PartitionList.partition_tag_array)
  return partition_tag_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PartitionList::mutable_partition_tag_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.PartitionList.partition_tag_array)
  return &partition_tag_array_;
}

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

// VectorRowRecord

// repeated float float_data = 1;
inline int VectorRowRecord::float_data_size() const {
  return float_data_.size();
}
inline void VectorRowRecord::clear_float_data() {
  float_data_.Clear();
}
inline float VectorRowRecord::float_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorRowRecord.float_data)
  return float_data_.Get(index);
}
inline void VectorRowRecord::set_float_data(int index, float value) {
  float_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorRowRecord.float_data)
}
inline void VectorRowRecord::add_float_data(float value) {
  float_data_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.VectorRowRecord.float_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
VectorRowRecord::float_data() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.VectorRowRecord.float_data)
  return float_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
VectorRowRecord::mutable_float_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorRowRecord.float_data)
  return &float_data_;
}

// bytes binary_data = 2;
inline void VectorRowRecord::clear_binary_data() {
  binary_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& VectorRowRecord::binary_data() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorRowRecord.binary_data)
  return binary_data_.GetNoArena();
}
inline void VectorRowRecord::set_binary_data(const std::string& value) {
  
  binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorRowRecord.binary_data)
}
inline void VectorRowRecord::set_binary_data(std::string&& value) {
  
  binary_data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorRowRecord.binary_data)
}
inline void VectorRowRecord::set_binary_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorRowRecord.binary_data)
}
inline void VectorRowRecord::set_binary_data(const void* value, size_t size) {
  
  binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorRowRecord.binary_data)
}
inline std::string* VectorRowRecord::mutable_binary_data() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorRowRecord.binary_data)
  return binary_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* VectorRowRecord::release_binary_data() {
  // @@protoc_insertion_point(field_release:milvus.grpc.VectorRowRecord.binary_data)
  
  return binary_data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void VectorRowRecord::set_allocated_binary_data(std::string* binary_data) {
  if (binary_data != nullptr) {
    
  } else {
    
  }
  binary_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), binary_data);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorRowRecord.binary_data)
}

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

// EntityIds

// .milvus.grpc.Status status = 1;
inline bool EntityIds::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void EntityIds::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& EntityIds::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.EntityIds.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* EntityIds::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.EntityIds.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* EntityIds::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.EntityIds.status)
  return status_;
}
inline void EntityIds::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.EntityIds.status)
}

// repeated int64 entity_id_array = 2;
inline int EntityIds::entity_id_array_size() const {
  return entity_id_array_.size();
}
inline void EntityIds::clear_entity_id_array() {
  entity_id_array_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 EntityIds::entity_id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.EntityIds.entity_id_array)
  return entity_id_array_.Get(index);
}
inline void EntityIds::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  entity_id_array_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.EntityIds.entity_id_array)
}
inline void EntityIds::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
  entity_id_array_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.EntityIds.entity_id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
EntityIds::entity_id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.EntityIds.entity_id_array)
  return entity_id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
EntityIds::mutable_entity_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.EntityIds.entity_id_array)
  return &entity_id_array_;
}

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

// VectorRecord

// repeated .milvus.grpc.VectorRowRecord records = 1;
inline int VectorRecord::records_size() const {
  return records_.size();
}
inline void VectorRecord::clear_records() {
  records_.Clear();
}
inline ::milvus::grpc::VectorRowRecord* VectorRecord::mutable_records(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorRecord.records)
  return records_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >*
VectorRecord::mutable_records() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorRecord.records)
  return &records_;
}
inline const ::milvus::grpc::VectorRowRecord& VectorRecord::records(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorRecord.records)
  return records_.Get(index);
}
inline ::milvus::grpc::VectorRowRecord* VectorRecord::add_records() {
  // @@protoc_insertion_point(field_add:milvus.grpc.VectorRecord.records)
  return records_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >&
VectorRecord::records() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.VectorRecord.records)
  return records_;
}

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

// VectorParam

// string json = 1;
inline void VectorParam::clear_json() {
  json_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& VectorParam::json() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorParam.json)
  return json_.GetNoArena();
}
inline void VectorParam::set_json(const std::string& value) {
  
  json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorParam.json)
}
inline void VectorParam::set_json(std::string&& value) {
  
  json_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorParam.json)
}
inline void VectorParam::set_json(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorParam.json)
}
inline void VectorParam::set_json(const char* value, size_t size) {
  
  json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorParam.json)
}
inline std::string* VectorParam::mutable_json() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorParam.json)
  return json_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* VectorParam::release_json() {
  // @@protoc_insertion_point(field_release:milvus.grpc.VectorParam.json)
  
  return json_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void VectorParam::set_allocated_json(std::string* json) {
  if (json != nullptr) {
    
  } else {
    
  }
  json_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), json);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorParam.json)
}

// .milvus.grpc.VectorRecord row_record = 2;
inline bool VectorParam::has_row_record() const {
  return this != internal_default_instance() && row_record_ != nullptr;
}
inline void VectorParam::clear_row_record() {
  if (GetArenaNoVirtual() == nullptr && row_record_ != nullptr) {
    delete row_record_;
  }
  row_record_ = nullptr;
}
inline const ::milvus::grpc::VectorRecord& VectorParam::row_record() const {
  const ::milvus::grpc::VectorRecord* p = row_record_;
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorParam.row_record)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::VectorRecord*>(
      &::milvus::grpc::_VectorRecord_default_instance_);
}
inline ::milvus::grpc::VectorRecord* VectorParam::release_row_record() {
  // @@protoc_insertion_point(field_release:milvus.grpc.VectorParam.row_record)
  
  ::milvus::grpc::VectorRecord* temp = row_record_;
  row_record_ = nullptr;
  return temp;
}
inline ::milvus::grpc::VectorRecord* VectorParam::mutable_row_record() {
  
  if (row_record_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::VectorRecord>(GetArenaNoVirtual());
    row_record_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorParam.row_record)
  return row_record_;
}
inline void VectorParam::set_allocated_row_record(::milvus::grpc::VectorRecord* row_record) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete row_record_;
  }
  if (row_record) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      row_record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, row_record, submessage_arena);
    }
    
  } else {
    
  }
  row_record_ = row_record;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorParam.row_record)
}

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

// FieldMeta

// string field_name = 1;
inline void FieldMeta::clear_field_name() {
  field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& FieldMeta::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldMeta.field_name)
  return field_name_.GetNoArena();
}
inline void FieldMeta::set_field_name(const std::string& value) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldMeta.field_name)
}
inline void FieldMeta::set_field_name(std::string&& value) {
  
  field_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldMeta.field_name)
}
inline void FieldMeta::set_field_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldMeta.field_name)
}
inline void FieldMeta::set_field_name(const char* value, size_t size) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldMeta.field_name)
}
inline std::string* FieldMeta::mutable_field_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldMeta.field_name)
  return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* FieldMeta::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.FieldMeta.field_name)
  
  return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void FieldMeta::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldMeta.field_name)
}

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

// int64 dim = 3;
inline void FieldMeta::clear_dim() {
  dim_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 FieldMeta::dim() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldMeta.dim)
  return dim_;
}
inline void FieldMeta::set_dim(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  dim_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldMeta.dim)
}

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

// Schema

// repeated .milvus.grpc.FieldMeta field_metas = 1;
inline int Schema::field_metas_size() const {
  return field_metas_.size();
}
inline void Schema::clear_field_metas() {
  field_metas_.Clear();
}
inline ::milvus::grpc::FieldMeta* Schema::mutable_field_metas(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Schema.field_metas)
  return field_metas_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >*
Schema::mutable_field_metas() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Schema.field_metas)
  return &field_metas_;
}
inline const ::milvus::grpc::FieldMeta& Schema::field_metas(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Schema.field_metas)
  return field_metas_.Get(index);
}
inline ::milvus::grpc::FieldMeta* Schema::add_field_metas() {
  // @@protoc_insertion_point(field_add:milvus.grpc.Schema.field_metas)
  return field_metas_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >&
Schema::field_metas() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.Schema.field_metas)
  return field_metas_;
}

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

// RowData

// bytes blob = 1;
inline void RowData::clear_blob() {
  blob_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& RowData::blob() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.RowData.blob)
  return blob_.GetNoArena();
}
inline void RowData::set_blob(const std::string& value) {
  
  blob_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.RowData.blob)
}
inline void RowData::set_blob(std::string&& value) {
  
  blob_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.RowData.blob)
}
inline void RowData::set_blob(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  blob_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.RowData.blob)
}
inline void RowData::set_blob(const void* value, size_t size) {
  
  blob_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.RowData.blob)
}
inline std::string* RowData::mutable_blob() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.RowData.blob)
  return blob_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* RowData::release_blob() {
  // @@protoc_insertion_point(field_release:milvus.grpc.RowData.blob)
  
  return blob_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void RowData::set_allocated_blob(std::string* blob) {
  if (blob != nullptr) {
    
  } else {
    
  }
  blob_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), blob);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.RowData.blob)
}

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

// InsertParam

// string collection_name = 1;
inline void InsertParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& InsertParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void InsertParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.collection_name)
}
inline void InsertParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.collection_name)
}
inline void InsertParam::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.grpc.InsertParam.collection_name)
}
inline void InsertParam::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.grpc.InsertParam.collection_name)
}
inline std::string* InsertParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* InsertParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void InsertParam::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.grpc.InsertParam.collection_name)
}

// .milvus.grpc.Schema schema = 2;
inline bool InsertParam::has_schema() const {
  return this != internal_default_instance() && schema_ != nullptr;
}
inline void InsertParam::clear_schema() {
  if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) {
    delete schema_;
  }
  schema_ = nullptr;
}
inline const ::milvus::grpc::Schema& InsertParam::schema() const {
  const ::milvus::grpc::Schema* p = schema_;
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.schema)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Schema*>(
      &::milvus::grpc::_Schema_default_instance_);
}
inline ::milvus::grpc::Schema* InsertParam::release_schema() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.schema)
  
  ::milvus::grpc::Schema* temp = schema_;
  schema_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Schema* InsertParam::mutable_schema() {
  
  if (schema_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Schema>(GetArenaNoVirtual());
    schema_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.schema)
  return schema_;
}
inline void InsertParam::set_allocated_schema(::milvus::grpc::Schema* schema) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.InsertParam.schema)
}

// repeated .milvus.grpc.RowData rows_data = 3;
inline int InsertParam::rows_data_size() const {
  return rows_data_.size();
}
inline void InsertParam::clear_rows_data() {
  rows_data_.Clear();
}
inline ::milvus::grpc::RowData* InsertParam::mutable_rows_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.rows_data)
  return rows_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >*
InsertParam::mutable_rows_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.rows_data)
  return &rows_data_;
}
inline const ::milvus::grpc::RowData& InsertParam::rows_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.rows_data)
  return rows_data_.Get(index);
}
inline ::milvus::grpc::RowData* InsertParam::add_rows_data() {
  // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.rows_data)
  return rows_data_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >&
InsertParam::rows_data() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.rows_data)
  return rows_data_;
}

// repeated int64 entity_id_array = 4;
inline int InsertParam::entity_id_array_size() const {
  return entity_id_array_.size();
}
inline void InsertParam::clear_entity_id_array() {
  entity_id_array_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 InsertParam::entity_id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.entity_id_array)
  return entity_id_array_.Get(index);
}
inline void InsertParam::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  entity_id_array_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.entity_id_array)
}
inline void InsertParam::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
  entity_id_array_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.entity_id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
InsertParam::entity_id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.entity_id_array)
  return entity_id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
InsertParam::mutable_entity_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.entity_id_array)
  return &entity_id_array_;
}

// string partition_tag = 5;
inline void InsertParam::clear_partition_tag() {
  partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& InsertParam::partition_tag() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.partition_tag)
  return partition_tag_.GetNoArena();
}
inline void InsertParam::set_partition_tag(const std::string& value) {
  
  partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.partition_tag)
}
inline void InsertParam::set_partition_tag(std::string&& value) {
  
  partition_tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.partition_tag)
}
inline void InsertParam::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.grpc.InsertParam.partition_tag)
}
inline void InsertParam::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.grpc.InsertParam.partition_tag)
}
inline std::string* InsertParam::mutable_partition_tag() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.partition_tag)
  return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* InsertParam::release_partition_tag() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.partition_tag)
  
  return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void InsertParam::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.grpc.InsertParam.partition_tag)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 6;
inline int InsertParam::extra_params_size() const {
  return extra_params_.size();
}
inline void InsertParam::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* InsertParam::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
InsertParam::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& InsertParam::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* InsertParam::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
InsertParam::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.extra_params)
  return extra_params_;
}

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

// SearchParam

// string collection_name = 1;
inline void SearchParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void SearchParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.collection_name)
}
inline void SearchParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.collection_name)
}
inline void SearchParam::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.grpc.SearchParam.collection_name)
}
inline void SearchParam::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.grpc.SearchParam.collection_name)
}
inline std::string* SearchParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchParam::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.grpc.SearchParam.collection_name)
}

// repeated .milvus.grpc.VectorParam vector_param = 2;
inline int SearchParam::vector_param_size() const {
  return vector_param_.size();
}
inline void SearchParam::clear_vector_param() {
  vector_param_.Clear();
}
inline ::milvus::grpc::VectorParam* SearchParam::mutable_vector_param(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.vector_param)
  return vector_param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >*
SearchParam::mutable_vector_param() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.vector_param)
  return &vector_param_;
}
inline const ::milvus::grpc::VectorParam& SearchParam::vector_param(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.vector_param)
  return vector_param_.Get(index);
}
inline ::milvus::grpc::VectorParam* SearchParam::add_vector_param() {
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.vector_param)
  return vector_param_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >&
SearchParam::vector_param() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.vector_param)
  return vector_param_;
}

// string dsl = 3;
inline void SearchParam::clear_dsl() {
  dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchParam::dsl() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.dsl)
  return dsl_.GetNoArena();
}
inline void SearchParam::set_dsl(const std::string& value) {
  
  dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.dsl)
}
inline void SearchParam::set_dsl(std::string&& value) {
  
  dsl_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.dsl)
}
inline void SearchParam::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.grpc.SearchParam.dsl)
}
inline void SearchParam::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.grpc.SearchParam.dsl)
}
inline std::string* SearchParam::mutable_dsl() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.dsl)
  return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchParam::release_dsl() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.dsl)
  
  return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchParam::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.grpc.SearchParam.dsl)
}

// repeated string partition_tag = 4;
inline int SearchParam::partition_tag_size() const {
  return partition_tag_.size();
}
inline void SearchParam::clear_partition_tag() {
  partition_tag_.Clear();
}
inline const std::string& SearchParam::partition_tag(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.partition_tag)
  return partition_tag_.Get(index);
}
inline std::string* SearchParam::mutable_partition_tag(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.partition_tag)
  return partition_tag_.Mutable(index);
}
inline void SearchParam::set_partition_tag(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.partition_tag)
  partition_tag_.Mutable(index)->assign(value);
}
inline void SearchParam::set_partition_tag(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.partition_tag)
  partition_tag_.Mutable(index)->assign(std::move(value));
}
inline void SearchParam::set_partition_tag(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.partition_tag)
}
inline void SearchParam::set_partition_tag(int index, const char* value, size_t size) {
  partition_tag_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.partition_tag)
}
inline std::string* SearchParam::add_partition_tag() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchParam.partition_tag)
  return partition_tag_.Add();
}
inline void SearchParam::add_partition_tag(const std::string& value) {
  partition_tag_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.partition_tag)
}
inline void SearchParam::add_partition_tag(std::string&& value) {
  partition_tag_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.partition_tag)
}
inline void SearchParam::add_partition_tag(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchParam.partition_tag)
}
inline void SearchParam::add_partition_tag(const char* value, size_t size) {
  partition_tag_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchParam.partition_tag)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchParam::partition_tag() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.partition_tag)
  return partition_tag_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchParam::mutable_partition_tag() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.partition_tag)
  return &partition_tag_;
}

// repeated .milvus.grpc.KeyValuePair extra_params = 5;
inline int SearchParam::extra_params_size() const {
  return extra_params_.size();
}
inline void SearchParam::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* SearchParam::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
SearchParam::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& SearchParam::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* SearchParam::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
SearchParam::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.extra_params)
  return extra_params_;
}

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

// SearchInSegmentParam

// repeated string file_id_array = 1;
inline int SearchInSegmentParam::file_id_array_size() const {
  return file_id_array_.size();
}
inline void SearchInSegmentParam::clear_file_id_array() {
  file_id_array_.Clear();
}
inline const std::string& SearchInSegmentParam::file_id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchInSegmentParam.file_id_array)
  return file_id_array_.Get(index);
}
inline std::string* SearchInSegmentParam::mutable_file_id_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchInSegmentParam.file_id_array)
  return file_id_array_.Mutable(index);
}
inline void SearchInSegmentParam::set_file_id_array(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchInSegmentParam.file_id_array)
  file_id_array_.Mutable(index)->assign(value);
}
inline void SearchInSegmentParam::set_file_id_array(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchInSegmentParam.file_id_array)
  file_id_array_.Mutable(index)->assign(std::move(value));
}
inline void SearchInSegmentParam::set_file_id_array(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  file_id_array_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchInSegmentParam.file_id_array)
}
inline void SearchInSegmentParam::set_file_id_array(int index, const char* value, size_t size) {
  file_id_array_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchInSegmentParam.file_id_array)
}
inline std::string* SearchInSegmentParam::add_file_id_array() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchInSegmentParam.file_id_array)
  return file_id_array_.Add();
}
inline void SearchInSegmentParam::add_file_id_array(const std::string& value) {
  file_id_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchInSegmentParam.file_id_array)
}
inline void SearchInSegmentParam::add_file_id_array(std::string&& value) {
  file_id_array_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchInSegmentParam.file_id_array)
}
inline void SearchInSegmentParam::add_file_id_array(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  file_id_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchInSegmentParam.file_id_array)
}
inline void SearchInSegmentParam::add_file_id_array(const char* value, size_t size) {
  file_id_array_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchInSegmentParam.file_id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchInSegmentParam::file_id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchInSegmentParam.file_id_array)
  return file_id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchInSegmentParam::mutable_file_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchInSegmentParam.file_id_array)
  return &file_id_array_;
}

// .milvus.grpc.SearchParam search_param = 2;
inline bool SearchInSegmentParam::has_search_param() const {
  return this != internal_default_instance() && search_param_ != nullptr;
}
inline void SearchInSegmentParam::clear_search_param() {
  if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) {
    delete search_param_;
  }
  search_param_ = nullptr;
}
inline const ::milvus::grpc::SearchParam& SearchInSegmentParam::search_param() const {
  const ::milvus::grpc::SearchParam* p = search_param_;
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchInSegmentParam.search_param)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::SearchParam*>(
      &::milvus::grpc::_SearchParam_default_instance_);
}
inline ::milvus::grpc::SearchParam* SearchInSegmentParam::release_search_param() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchInSegmentParam.search_param)
  
  ::milvus::grpc::SearchParam* temp = search_param_;
  search_param_ = nullptr;
  return temp;
}
inline ::milvus::grpc::SearchParam* SearchInSegmentParam::mutable_search_param() {
  
  if (search_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::SearchParam>(GetArenaNoVirtual());
    search_param_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchInSegmentParam.search_param)
  return search_param_;
}
inline void SearchInSegmentParam::set_allocated_search_param(::milvus::grpc::SearchParam* search_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete search_param_;
  }
  if (search_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      search_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, search_param, submessage_arena);
    }
    
  } else {
    
  }
  search_param_ = search_param;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchInSegmentParam.search_param)
}

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

// Entities

// .milvus.grpc.Status status = 1;
inline bool Entities::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void Entities::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& Entities::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.Entities.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* Entities::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Entities.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* Entities::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Entities.status)
  return status_;
}
inline void Entities::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.Entities.status)
}

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

// repeated bool valid_row = 3;
inline int Entities::valid_row_size() const {
  return valid_row_.size();
}
inline void Entities::clear_valid_row() {
  valid_row_.Clear();
}
inline bool Entities::valid_row(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Entities.valid_row)
  return valid_row_.Get(index);
}
inline void Entities::set_valid_row(int index, bool value) {
  valid_row_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Entities.valid_row)
}
inline void Entities::add_valid_row(bool value) {
  valid_row_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.Entities.valid_row)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
Entities::valid_row() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.Entities.valid_row)
  return valid_row_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
Entities::mutable_valid_row() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Entities.valid_row)
  return &valid_row_;
}

// repeated .milvus.grpc.RowData rows_data = 4;
inline int Entities::rows_data_size() const {
  return rows_data_.size();
}
inline void Entities::clear_rows_data() {
  rows_data_.Clear();
}
inline ::milvus::grpc::RowData* Entities::mutable_rows_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Entities.rows_data)
  return rows_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >*
Entities::mutable_rows_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Entities.rows_data)
  return &rows_data_;
}
inline const ::milvus::grpc::RowData& Entities::rows_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Entities.rows_data)
  return rows_data_.Get(index);
}
inline ::milvus::grpc::RowData* Entities::add_rows_data() {
  // @@protoc_insertion_point(field_add:milvus.grpc.Entities.rows_data)
  return rows_data_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >&
Entities::rows_data() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.Entities.rows_data)
  return rows_data_;
}

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

// QueryResult

// .milvus.grpc.Status status = 1;
inline bool QueryResult::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void QueryResult::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& QueryResult::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* QueryResult::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.QueryResult.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* QueryResult::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryResult.status)
  return status_;
}
inline void QueryResult::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.QueryResult.status)
}

// .milvus.grpc.Entities entities = 2;
inline bool QueryResult::has_entities() const {
  return this != internal_default_instance() && entities_ != nullptr;
}
inline void QueryResult::clear_entities() {
  if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) {
    delete entities_;
  }
  entities_ = nullptr;
}
inline const ::milvus::grpc::Entities& QueryResult::entities() const {
  const ::milvus::grpc::Entities* p = entities_;
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.entities)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Entities*>(
      &::milvus::grpc::_Entities_default_instance_);
}
inline ::milvus::grpc::Entities* QueryResult::release_entities() {
  // @@protoc_insertion_point(field_release:milvus.grpc.QueryResult.entities)
  
  ::milvus::grpc::Entities* temp = entities_;
  entities_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Entities* QueryResult::mutable_entities() {
  
  if (entities_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Entities>(GetArenaNoVirtual());
    entities_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryResult.entities)
  return entities_;
}
inline void QueryResult::set_allocated_entities(::milvus::grpc::Entities* entities) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete entities_;
  }
  if (entities) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entities, submessage_arena);
    }
    
  } else {
    
  }
  entities_ = entities;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.QueryResult.entities)
}

// int64 row_num = 3;
inline void QueryResult::clear_row_num() {
  row_num_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::row_num() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.row_num)
  return row_num_;
}
inline void QueryResult::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  row_num_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.row_num)
}

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

// repeated float distances = 5;
inline int QueryResult::distances_size() const {
  return distances_.size();
}
inline void QueryResult::clear_distances() {
  distances_.Clear();
}
inline float QueryResult::distances(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.distances)
  return distances_.Get(index);
}
inline void QueryResult::set_distances(int index, float value) {
  distances_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.distances)
}
inline void QueryResult::add_distances(float value) {
  distances_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.QueryResult.distances)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
QueryResult::distances() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.QueryResult.distances)
  return distances_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
QueryResult::mutable_distances() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryResult.distances)
  return &distances_;
}

// repeated .milvus.grpc.KeyValuePair extra_params = 6;
inline int QueryResult::extra_params_size() const {
  return extra_params_.size();
}
inline void QueryResult::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* QueryResult::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryResult.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
QueryResult::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryResult.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& QueryResult::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* QueryResult::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.QueryResult.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
QueryResult::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.QueryResult.extra_params)
  return extra_params_;
}

// int64 query_id = 7;
inline void QueryResult::clear_query_id() {
  query_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::query_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.query_id)
  return query_id_;
}
inline void QueryResult::set_query_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  query_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.query_id)
}

// int64 client_id = 8;
inline void QueryResult::clear_client_id() {
  client_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::client_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.client_id)
  return client_id_;
}
inline void QueryResult::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  client_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.client_id)
}

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

// StringReply

// .milvus.grpc.Status status = 1;
inline bool StringReply::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void StringReply::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& StringReply::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.StringReply.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* StringReply::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.StringReply.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* StringReply::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.StringReply.status)
  return status_;
}
inline void StringReply::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.StringReply.status)
}

// string string_reply = 2;
inline void StringReply::clear_string_reply() {
  string_reply_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& StringReply::string_reply() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.StringReply.string_reply)
  return string_reply_.GetNoArena();
}
inline void StringReply::set_string_reply(const std::string& value) {
  
  string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.StringReply.string_reply)
}
inline void StringReply::set_string_reply(std::string&& value) {
  
  string_reply_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.StringReply.string_reply)
}
inline void StringReply::set_string_reply(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.StringReply.string_reply)
}
inline void StringReply::set_string_reply(const char* value, size_t size) {
  
  string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.StringReply.string_reply)
}
inline std::string* StringReply::mutable_string_reply() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.StringReply.string_reply)
  return string_reply_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* StringReply::release_string_reply() {
  // @@protoc_insertion_point(field_release:milvus.grpc.StringReply.string_reply)
  
  return string_reply_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void StringReply::set_allocated_string_reply(std::string* string_reply) {
  if (string_reply != nullptr) {
    
  } else {
    
  }
  string_reply_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), string_reply);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.StringReply.string_reply)
}

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

// BoolReply

// .milvus.grpc.Status status = 1;
inline bool BoolReply::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void BoolReply::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& BoolReply::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.BoolReply.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* BoolReply::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.BoolReply.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* BoolReply::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.BoolReply.status)
  return status_;
}
inline void BoolReply::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.BoolReply.status)
}

// bool bool_reply = 2;
inline void BoolReply::clear_bool_reply() {
  bool_reply_ = false;
}
inline bool BoolReply::bool_reply() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.BoolReply.bool_reply)
  return bool_reply_;
}
inline void BoolReply::set_bool_reply(bool value) {
  
  bool_reply_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.BoolReply.bool_reply)
}

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

// CollectionRowCount

// .milvus.grpc.Status status = 1;
inline bool CollectionRowCount::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void CollectionRowCount::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& CollectionRowCount::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* CollectionRowCount::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.CollectionRowCount.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* CollectionRowCount::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionRowCount.status)
  return status_;
}
inline void CollectionRowCount::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.CollectionRowCount.status)
}

// int64 collection_row_count = 2;
inline void CollectionRowCount::clear_collection_row_count() {
  collection_row_count_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionRowCount::collection_row_count() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.collection_row_count)
  return collection_row_count_;
}
inline void CollectionRowCount::set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  collection_row_count_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.CollectionRowCount.collection_row_count)
}

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

// Command

// string cmd = 1;
inline void Command::clear_cmd() {
  cmd_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Command::cmd() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Command.cmd)
  return cmd_.GetNoArena();
}
inline void Command::set_cmd(const std::string& value) {
  
  cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Command.cmd)
}
inline void Command::set_cmd(std::string&& value) {
  
  cmd_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Command.cmd)
}
inline void Command::set_cmd(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.Command.cmd)
}
inline void Command::set_cmd(const char* value, size_t size) {
  
  cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Command.cmd)
}
inline std::string* Command::mutable_cmd() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Command.cmd)
  return cmd_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Command::release_cmd() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Command.cmd)
  
  return cmd_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Command::set_allocated_cmd(std::string* cmd) {
  if (cmd != nullptr) {
    
  } else {
    
  }
  cmd_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cmd);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Command.cmd)
}

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

// IndexParam

// .milvus.grpc.Status status = 1;
inline bool IndexParam::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void IndexParam::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& IndexParam::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* IndexParam::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* IndexParam::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.status)
  return status_;
}
inline void IndexParam::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.IndexParam.status)
}

// string collection_name = 2;
inline void IndexParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& IndexParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void IndexParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.collection_name)
}
inline void IndexParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.collection_name)
}
inline void IndexParam::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.grpc.IndexParam.collection_name)
}
inline void IndexParam::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.grpc.IndexParam.collection_name)
}
inline std::string* IndexParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* IndexParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void IndexParam::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.grpc.IndexParam.collection_name)
}

// string field_name = 3;
inline void IndexParam::clear_field_name() {
  field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& IndexParam::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.field_name)
  return field_name_.GetNoArena();
}
inline void IndexParam::set_field_name(const std::string& value) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.field_name)
}
inline void IndexParam::set_field_name(std::string&& value) {
  
  field_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.field_name)
}
inline void IndexParam::set_field_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.field_name)
}
inline void IndexParam::set_field_name(const char* value, size_t size) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.field_name)
}
inline std::string* IndexParam::mutable_field_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.field_name)
  return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* IndexParam::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.field_name)
  
  return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void IndexParam::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.field_name)
}

// string index_name = 4;
inline void IndexParam::clear_index_name() {
  index_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& IndexParam::index_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.index_name)
  return index_name_.GetNoArena();
}
inline void IndexParam::set_index_name(const std::string& value) {
  
  index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.index_name)
}
inline void IndexParam::set_index_name(std::string&& value) {
  
  index_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.index_name)
}
inline void IndexParam::set_index_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.index_name)
}
inline void IndexParam::set_index_name(const char* value, size_t size) {
  
  index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.index_name)
}
inline std::string* IndexParam::mutable_index_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.index_name)
  return index_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* IndexParam::release_index_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.index_name)
  
  return index_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void IndexParam::set_allocated_index_name(std::string* index_name) {
  if (index_name != nullptr) {
    
  } else {
    
  }
  index_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), index_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.index_name)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 5;
inline int IndexParam::extra_params_size() const {
  return extra_params_.size();
}
inline void IndexParam::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* IndexParam::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
IndexParam::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.IndexParam.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& IndexParam::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* IndexParam::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.IndexParam.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
IndexParam::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.IndexParam.extra_params)
  return extra_params_;
}

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

// FlushParam

// repeated string collection_name_array = 1;
inline int FlushParam::collection_name_array_size() const {
  return collection_name_array_.size();
}
inline void FlushParam::clear_collection_name_array() {
  collection_name_array_.Clear();
}
inline const std::string& FlushParam::collection_name_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FlushParam.collection_name_array)
  return collection_name_array_.Get(index);
}
inline std::string* FlushParam::mutable_collection_name_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FlushParam.collection_name_array)
  return collection_name_array_.Mutable(index);
}
inline void FlushParam::set_collection_name_array(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array)
  collection_name_array_.Mutable(index)->assign(value);
}
inline void FlushParam::set_collection_name_array(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array)
  collection_name_array_.Mutable(index)->assign(std::move(value));
}
inline void FlushParam::set_collection_name_array(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  collection_name_array_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.FlushParam.collection_name_array)
}
inline void FlushParam::set_collection_name_array(int index, const char* value, size_t size) {
  collection_name_array_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FlushParam.collection_name_array)
}
inline std::string* FlushParam::add_collection_name_array() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.FlushParam.collection_name_array)
  return collection_name_array_.Add();
}
inline void FlushParam::add_collection_name_array(const std::string& value) {
  collection_name_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array)
}
inline void FlushParam::add_collection_name_array(std::string&& value) {
  collection_name_array_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array)
}
inline void FlushParam::add_collection_name_array(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  collection_name_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.FlushParam.collection_name_array)
}
inline void FlushParam::add_collection_name_array(const char* value, size_t size) {
  collection_name_array_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.FlushParam.collection_name_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FlushParam::collection_name_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.FlushParam.collection_name_array)
  return collection_name_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FlushParam::mutable_collection_name_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FlushParam.collection_name_array)
  return &collection_name_array_;
}

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

// CompactParam

// string collection_name = 1;
inline void CompactParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CompactParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CompactParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void CompactParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.CompactParam.collection_name)
}
inline void CompactParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CompactParam.collection_name)
}
inline void CompactParam::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.grpc.CompactParam.collection_name)
}
inline void CompactParam::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.grpc.CompactParam.collection_name)
}
inline std::string* CompactParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CompactParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CompactParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.CompactParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CompactParam::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.grpc.CompactParam.collection_name)
}

// double threshold = 2;
inline void CompactParam::clear_threshold() {
  threshold_ = 0;
}
inline double CompactParam::threshold() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CompactParam.threshold)
  return threshold_;
}
inline void CompactParam::set_threshold(double value) {
  
  threshold_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.CompactParam.threshold)
}

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

// DeleteByIDParam

// string collection_name = 1;
inline void DeleteByIDParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DeleteByIDParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void DeleteByIDParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.collection_name)
}
inline void DeleteByIDParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByIDParam.collection_name)
}
inline void DeleteByIDParam::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.grpc.DeleteByIDParam.collection_name)
}
inline void DeleteByIDParam::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.grpc.DeleteByIDParam.collection_name)
}
inline std::string* DeleteByIDParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByIDParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeleteByIDParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByIDParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeleteByIDParam::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.grpc.DeleteByIDParam.collection_name)
}

// repeated int64 id_array = 2;
inline int DeleteByIDParam::id_array_size() const {
  return id_array_.size();
}
inline void DeleteByIDParam::clear_id_array() {
  id_array_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeleteByIDParam::id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.id_array)
  return id_array_.Get(index);
}
inline void DeleteByIDParam::set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  id_array_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.id_array)
}
inline void DeleteByIDParam::add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
  id_array_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.DeleteByIDParam.id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
DeleteByIDParam::id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.DeleteByIDParam.id_array)
  return id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
DeleteByIDParam::mutable_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.DeleteByIDParam.id_array)
  return &id_array_;
}

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

// CollectionInfo

// .milvus.grpc.Status status = 1;
inline bool CollectionInfo::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline void CollectionInfo::clear_status() {
  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::milvus::grpc::Status& CollectionInfo::status() const {
  const ::milvus::grpc::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
      &::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* CollectionInfo::release_status() {
  // @@protoc_insertion_point(field_release:milvus.grpc.CollectionInfo.status)
  
  ::milvus::grpc::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Status* CollectionInfo::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.status)
  return status_;
}
inline void CollectionInfo::set_allocated_status(::milvus::grpc::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete 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.grpc.CollectionInfo.status)
}

// string json_info = 2;
inline void CollectionInfo::clear_json_info() {
  json_info_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CollectionInfo::json_info() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.json_info)
  return json_info_.GetNoArena();
}
inline void CollectionInfo::set_json_info(const std::string& value) {
  
  json_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.CollectionInfo.json_info)
}
inline void CollectionInfo::set_json_info(std::string&& value) {
  
  json_info_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionInfo.json_info)
}
inline void CollectionInfo::set_json_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  json_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionInfo.json_info)
}
inline void CollectionInfo::set_json_info(const char* value, size_t size) {
  
  json_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionInfo.json_info)
}
inline std::string* CollectionInfo::mutable_json_info() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.json_info)
  return json_info_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CollectionInfo::release_json_info() {
  // @@protoc_insertion_point(field_release:milvus.grpc.CollectionInfo.json_info)
  
  return json_info_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CollectionInfo::set_allocated_json_info(std::string* json_info) {
  if (json_info != nullptr) {
    
  } else {
    
  }
  json_info_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), json_info);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionInfo.json_info)
}

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

// GetEntityIDsParam

// string collection_name = 1;
inline void GetEntityIDsParam::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetEntityIDsParam::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.GetEntityIDsParam.collection_name)
  return collection_name_.GetNoArena();
}
inline void GetEntityIDsParam::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.GetEntityIDsParam.collection_name)
}
inline void GetEntityIDsParam::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.GetEntityIDsParam.collection_name)
}
inline void GetEntityIDsParam::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.grpc.GetEntityIDsParam.collection_name)
}
inline void GetEntityIDsParam::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.grpc.GetEntityIDsParam.collection_name)
}
inline std::string* GetEntityIDsParam::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.GetEntityIDsParam.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetEntityIDsParam::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.GetEntityIDsParam.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetEntityIDsParam::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.grpc.GetEntityIDsParam.collection_name)
}

// int64 segment_id = 2;
inline void GetEntityIDsParam::clear_segment_id() {
  segment_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GetEntityIDsParam::segment_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.GetEntityIDsParam.segment_id)
  return segment_id_;
}
inline void GetEntityIDsParam::set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  segment_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.GetEntityIDsParam.segment_id)
}

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

// EntityIdentity

// string collection_name = 1;
inline void EntityIdentity::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& EntityIdentity::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.EntityIdentity.collection_name)
  return collection_name_.GetNoArena();
}
inline void EntityIdentity::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.collection_name)
}
inline void EntityIdentity::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.EntityIdentity.collection_name)
}
inline void EntityIdentity::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.grpc.EntityIdentity.collection_name)
}
inline void EntityIdentity::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.grpc.EntityIdentity.collection_name)
}
inline std::string* EntityIdentity::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.EntityIdentity.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* EntityIdentity::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.EntityIdentity.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void EntityIdentity::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.grpc.EntityIdentity.collection_name)
}

// repeated int64 id_array = 2;
inline int EntityIdentity::id_array_size() const {
  return id_array_.size();
}
inline void EntityIdentity::clear_id_array() {
  id_array_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 EntityIdentity::id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.EntityIdentity.id_array)
  return id_array_.Get(index);
}
inline void EntityIdentity::set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  id_array_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.id_array)
}
inline void EntityIdentity::add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
  id_array_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.EntityIdentity.id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
EntityIdentity::id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.EntityIdentity.id_array)
  return id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
EntityIdentity::mutable_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.EntityIdentity.id_array)
  return &id_array_;
}

// repeated string field_names = 3;
inline int EntityIdentity::field_names_size() const {
  return field_names_.size();
}
inline void EntityIdentity::clear_field_names() {
  field_names_.Clear();
}
inline const std::string& EntityIdentity::field_names(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.EntityIdentity.field_names)
  return field_names_.Get(index);
}
inline std::string* EntityIdentity::mutable_field_names(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.EntityIdentity.field_names)
  return field_names_.Mutable(index);
}
inline void EntityIdentity::set_field_names(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.field_names)
  field_names_.Mutable(index)->assign(value);
}
inline void EntityIdentity::set_field_names(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.field_names)
  field_names_.Mutable(index)->assign(std::move(value));
}
inline void EntityIdentity::set_field_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  field_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.EntityIdentity.field_names)
}
inline void EntityIdentity::set_field_names(int index, const char* value, size_t size) {
  field_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.EntityIdentity.field_names)
}
inline std::string* EntityIdentity::add_field_names() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.EntityIdentity.field_names)
  return field_names_.Add();
}
inline void EntityIdentity::add_field_names(const std::string& value) {
  field_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.EntityIdentity.field_names)
}
inline void EntityIdentity::add_field_names(std::string&& value) {
  field_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.EntityIdentity.field_names)
}
inline void EntityIdentity::add_field_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  field_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.EntityIdentity.field_names)
}
inline void EntityIdentity::add_field_names(const char* value, size_t size) {
  field_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.EntityIdentity.field_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
EntityIdentity::field_names() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.EntityIdentity.field_names)
  return field_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
EntityIdentity::mutable_field_names() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.EntityIdentity.field_names)
  return &field_names_;
}

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

// VectorFieldParam

// int64 dimension = 1;
inline void VectorFieldParam::clear_dimension() {
  dimension_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 VectorFieldParam::dimension() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldParam.dimension)
  return dimension_;
}
inline void VectorFieldParam::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  dimension_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorFieldParam.dimension)
}

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

// FieldType

// .milvus.grpc.DataType data_type = 1;
inline bool FieldType::has_data_type() const {
  return value_case() == kDataType;
}
inline void FieldType::set_has_data_type() {
  _oneof_case_[0] = kDataType;
}
inline void FieldType::clear_data_type() {
  if (has_data_type()) {
    value_.data_type_ = 0;
    clear_has_value();
  }
}
inline ::milvus::grpc::DataType FieldType::data_type() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.data_type)
  if (has_data_type()) {
    return static_cast< ::milvus::grpc::DataType >(value_.data_type_);
  }
  return static_cast< ::milvus::grpc::DataType >(0);
}
inline void FieldType::set_data_type(::milvus::grpc::DataType value) {
  if (!has_data_type()) {
    clear_value();
    set_has_data_type();
  }
  value_.data_type_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldType.data_type)
}

// .milvus.grpc.VectorFieldParam vector_param = 2;
inline bool FieldType::has_vector_param() const {
  return value_case() == kVectorParam;
}
inline void FieldType::set_has_vector_param() {
  _oneof_case_[0] = kVectorParam;
}
inline void FieldType::clear_vector_param() {
  if (has_vector_param()) {
    delete value_.vector_param_;
    clear_has_value();
  }
}
inline ::milvus::grpc::VectorFieldParam* FieldType::release_vector_param() {
  // @@protoc_insertion_point(field_release:milvus.grpc.FieldType.vector_param)
  if (has_vector_param()) {
    clear_has_value();
      ::milvus::grpc::VectorFieldParam* temp = value_.vector_param_;
    value_.vector_param_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::grpc::VectorFieldParam& FieldType::vector_param() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.vector_param)
  return has_vector_param()
      ? *value_.vector_param_
      : *reinterpret_cast< ::milvus::grpc::VectorFieldParam*>(&::milvus::grpc::_VectorFieldParam_default_instance_);
}
inline ::milvus::grpc::VectorFieldParam* FieldType::mutable_vector_param() {
  if (!has_vector_param()) {
    clear_value();
    set_has_vector_param();
    value_.vector_param_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldType.vector_param)
  return value_.vector_param_;
}

inline bool FieldType::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void FieldType::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline FieldType::ValueCase FieldType::value_case() const {
  return FieldType::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// FieldParam

// uint64 id = 1;
inline void FieldParam::clear_id() {
  id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 FieldParam::id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.id)
  return id_;
}
inline void FieldParam::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.id)
}

// string name = 2;
inline void FieldParam::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& FieldParam::name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.name)
  return name_.GetNoArena();
}
inline void FieldParam::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.name)
}
inline void FieldParam::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldParam.name)
}
inline void FieldParam::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldParam.name)
}
inline void FieldParam::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldParam.name)
}
inline std::string* FieldParam::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* FieldParam::release_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.FieldParam.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void FieldParam::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldParam.name)
}

// .milvus.grpc.DataType type = 3;
inline void FieldParam::clear_type() {
  type_ = 0;
}
inline ::milvus::grpc::DataType FieldParam::type() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.type)
  return static_cast< ::milvus::grpc::DataType >(type_);
}
inline void FieldParam::set_type(::milvus::grpc::DataType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.type)
}

// repeated .milvus.grpc.KeyValuePair index_params = 4;
inline int FieldParam::index_params_size() const {
  return index_params_.size();
}
inline void FieldParam::clear_index_params() {
  index_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* FieldParam::mutable_index_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.index_params)
  return index_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
FieldParam::mutable_index_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FieldParam.index_params)
  return &index_params_;
}
inline const ::milvus::grpc::KeyValuePair& FieldParam::index_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.index_params)
  return index_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* FieldParam::add_index_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.FieldParam.index_params)
  return index_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
FieldParam::index_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.FieldParam.index_params)
  return index_params_;
}

// repeated .milvus.grpc.KeyValuePair extra_params = 5;
inline int FieldParam::extra_params_size() const {
  return extra_params_.size();
}
inline void FieldParam::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* FieldParam::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
FieldParam::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FieldParam.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& FieldParam::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* FieldParam::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.FieldParam.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
FieldParam::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.FieldParam.extra_params)
  return extra_params_;
}

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

// VectorFieldRecord

// repeated .milvus.grpc.VectorRowRecord value = 1;
inline int VectorFieldRecord::value_size() const {
  return value_.size();
}
inline void VectorFieldRecord::clear_value() {
  value_.Clear();
}
inline ::milvus::grpc::VectorRowRecord* VectorFieldRecord::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldRecord.value)
  return value_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >*
VectorFieldRecord::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorFieldRecord.value)
  return &value_;
}
inline const ::milvus::grpc::VectorRowRecord& VectorFieldRecord::value(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldRecord.value)
  return value_.Get(index);
}
inline ::milvus::grpc::VectorRowRecord* VectorFieldRecord::add_value() {
  // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldRecord.value)
  return value_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >&
VectorFieldRecord::value() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.VectorFieldRecord.value)
  return value_;
}

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

// TermQuery

// string field_name = 1;
inline void TermQuery::clear_field_name() {
  field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TermQuery::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.field_name)
  return field_name_.GetNoArena();
}
inline void TermQuery::set_field_name(const std::string& value) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.field_name)
}
inline void TermQuery::set_field_name(std::string&& value) {
  
  field_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TermQuery.field_name)
}
inline void TermQuery::set_field_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.field_name)
}
inline void TermQuery::set_field_name(const char* value, size_t size) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.field_name)
}
inline std::string* TermQuery::mutable_field_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.field_name)
  return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TermQuery::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.TermQuery.field_name)
  
  return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TermQuery::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.field_name)
}

// repeated int64 int_value = 2;
inline int TermQuery::int_value_size() const {
  return int_value_.size();
}
inline void TermQuery::clear_int_value() {
  int_value_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TermQuery::int_value(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.int_value)
  return int_value_.Get(index);
}
inline void TermQuery::set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  int_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.int_value)
}
inline void TermQuery::add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
  int_value_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.int_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TermQuery::int_value() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.int_value)
  return int_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TermQuery::mutable_int_value() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.int_value)
  return &int_value_;
}

// repeated double double_value = 3;
inline int TermQuery::double_value_size() const {
  return double_value_.size();
}
inline void TermQuery::clear_double_value() {
  double_value_.Clear();
}
inline double TermQuery::double_value(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.double_value)
  return double_value_.Get(index);
}
inline void TermQuery::set_double_value(int index, double value) {
  double_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.double_value)
}
inline void TermQuery::add_double_value(double value) {
  double_value_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.double_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TermQuery::double_value() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.double_value)
  return double_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TermQuery::mutable_double_value() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.double_value)
  return &double_value_;
}

// int64 value_num = 4;
inline void TermQuery::clear_value_num() {
  value_num_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TermQuery::value_num() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.value_num)
  return value_num_;
}
inline void TermQuery::set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  value_num_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.value_num)
}

// float boost = 5;
inline void TermQuery::clear_boost() {
  boost_ = 0;
}
inline float TermQuery::boost() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.boost)
  return boost_;
}
inline void TermQuery::set_boost(float value) {
  
  boost_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.boost)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 6;
inline int TermQuery::extra_params_size() const {
  return extra_params_.size();
}
inline void TermQuery::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* TermQuery::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
TermQuery::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& TermQuery::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* TermQuery::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
TermQuery::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.extra_params)
  return extra_params_;
}

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

// CompareExpr

// .milvus.grpc.CompareOperator operator = 1;
inline void CompareExpr::clear_operator_() {
  operator__ = 0;
}
inline ::milvus::grpc::CompareOperator CompareExpr::operator_() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operator)
  return static_cast< ::milvus::grpc::CompareOperator >(operator__);
}
inline void CompareExpr::set_operator_(::milvus::grpc::CompareOperator value) {
  
  operator__ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operator)
}

// string operand = 2;
inline void CompareExpr::clear_operand() {
  operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CompareExpr::operand() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operand)
  return operand_.GetNoArena();
}
inline void CompareExpr::set_operand(const std::string& value) {
  
  operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operand)
}
inline void CompareExpr::set_operand(std::string&& value) {
  
  operand_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CompareExpr.operand)
}
inline void CompareExpr::set_operand(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.CompareExpr.operand)
}
inline void CompareExpr::set_operand(const char* value, size_t size) {
  
  operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CompareExpr.operand)
}
inline std::string* CompareExpr::mutable_operand() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.CompareExpr.operand)
  return operand_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CompareExpr::release_operand() {
  // @@protoc_insertion_point(field_release:milvus.grpc.CompareExpr.operand)
  
  return operand_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CompareExpr::set_allocated_operand(std::string* operand) {
  if (operand != nullptr) {
    
  } else {
    
  }
  operand_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), operand);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CompareExpr.operand)
}

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

// RangeQuery

// string field_name = 1;
inline void RangeQuery::clear_field_name() {
  field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& RangeQuery::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.field_name)
  return field_name_.GetNoArena();
}
inline void RangeQuery::set_field_name(const std::string& value) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.field_name)
}
inline void RangeQuery::set_field_name(std::string&& value) {
  
  field_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.RangeQuery.field_name)
}
inline void RangeQuery::set_field_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.RangeQuery.field_name)
}
inline void RangeQuery::set_field_name(const char* value, size_t size) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.RangeQuery.field_name)
}
inline std::string* RangeQuery::mutable_field_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.field_name)
  return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* RangeQuery::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.RangeQuery.field_name)
  
  return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void RangeQuery::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.RangeQuery.field_name)
}

// repeated .milvus.grpc.CompareExpr operand = 2;
inline int RangeQuery::operand_size() const {
  return operand_.size();
}
inline void RangeQuery::clear_operand() {
  operand_.Clear();
}
inline ::milvus::grpc::CompareExpr* RangeQuery::mutable_operand(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.operand)
  return operand_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >*
RangeQuery::mutable_operand() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.operand)
  return &operand_;
}
inline const ::milvus::grpc::CompareExpr& RangeQuery::operand(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.operand)
  return operand_.Get(index);
}
inline ::milvus::grpc::CompareExpr* RangeQuery::add_operand() {
  // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.operand)
  return operand_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >&
RangeQuery::operand() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.operand)
  return operand_;
}

// float boost = 3;
inline void RangeQuery::clear_boost() {
  boost_ = 0;
}
inline float RangeQuery::boost() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.boost)
  return boost_;
}
inline void RangeQuery::set_boost(float value) {
  
  boost_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.boost)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 4;
inline int RangeQuery::extra_params_size() const {
  return extra_params_.size();
}
inline void RangeQuery::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* RangeQuery::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
RangeQuery::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& RangeQuery::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* RangeQuery::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
RangeQuery::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.extra_params)
  return extra_params_;
}

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

// VectorQuery

// string field_name = 1;
inline void VectorQuery::clear_field_name() {
  field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& VectorQuery::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.field_name)
  return field_name_.GetNoArena();
}
inline void VectorQuery::set_field_name(const std::string& value) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.field_name)
}
inline void VectorQuery::set_field_name(std::string&& value) {
  
  field_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorQuery.field_name)
}
inline void VectorQuery::set_field_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorQuery.field_name)
}
inline void VectorQuery::set_field_name(const char* value, size_t size) {
  
  field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorQuery.field_name)
}
inline std::string* VectorQuery::mutable_field_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.field_name)
  return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* VectorQuery::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.VectorQuery.field_name)
  
  return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void VectorQuery::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorQuery.field_name)
}

// float query_boost = 2;
inline void VectorQuery::clear_query_boost() {
  query_boost_ = 0;
}
inline float VectorQuery::query_boost() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.query_boost)
  return query_boost_;
}
inline void VectorQuery::set_query_boost(float value) {
  
  query_boost_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.query_boost)
}

// repeated .milvus.grpc.VectorRowRecord records = 3;
inline int VectorQuery::records_size() const {
  return records_.size();
}
inline void VectorQuery::clear_records() {
  records_.Clear();
}
inline ::milvus::grpc::VectorRowRecord* VectorQuery::mutable_records(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.records)
  return records_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >*
VectorQuery::mutable_records() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.records)
  return &records_;
}
inline const ::milvus::grpc::VectorRowRecord& VectorQuery::records(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.records)
  return records_.Get(index);
}
inline ::milvus::grpc::VectorRowRecord* VectorQuery::add_records() {
  // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.records)
  return records_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >&
VectorQuery::records() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.records)
  return records_;
}

// int64 topk = 4;
inline void VectorQuery::clear_topk() {
  topk_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 VectorQuery::topk() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.topk)
  return topk_;
}
inline void VectorQuery::set_topk(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  topk_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.topk)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 5;
inline int VectorQuery::extra_params_size() const {
  return extra_params_.size();
}
inline void VectorQuery::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* VectorQuery::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
VectorQuery::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& VectorQuery::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* VectorQuery::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
VectorQuery::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.extra_params)
  return extra_params_;
}

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

// BooleanQuery

// .milvus.grpc.Occur occur = 1;
inline void BooleanQuery::clear_occur() {
  occur_ = 0;
}
inline ::milvus::grpc::Occur BooleanQuery::occur() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.occur)
  return static_cast< ::milvus::grpc::Occur >(occur_);
}
inline void BooleanQuery::set_occur(::milvus::grpc::Occur value) {
  
  occur_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.BooleanQuery.occur)
}

// repeated .milvus.grpc.GeneralQuery general_query = 2;
inline int BooleanQuery::general_query_size() const {
  return general_query_.size();
}
inline void BooleanQuery::clear_general_query() {
  general_query_.Clear();
}
inline ::milvus::grpc::GeneralQuery* BooleanQuery::mutable_general_query(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.BooleanQuery.general_query)
  return general_query_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >*
BooleanQuery::mutable_general_query() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.BooleanQuery.general_query)
  return &general_query_;
}
inline const ::milvus::grpc::GeneralQuery& BooleanQuery::general_query(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.general_query)
  return general_query_.Get(index);
}
inline ::milvus::grpc::GeneralQuery* BooleanQuery::add_general_query() {
  // @@protoc_insertion_point(field_add:milvus.grpc.BooleanQuery.general_query)
  return general_query_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >&
BooleanQuery::general_query() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.BooleanQuery.general_query)
  return general_query_;
}

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

// GeneralQuery

// .milvus.grpc.BooleanQuery boolean_query = 1;
inline bool GeneralQuery::has_boolean_query() const {
  return query_case() == kBooleanQuery;
}
inline void GeneralQuery::set_has_boolean_query() {
  _oneof_case_[0] = kBooleanQuery;
}
inline void GeneralQuery::clear_boolean_query() {
  if (has_boolean_query()) {
    delete query_.boolean_query_;
    clear_has_query();
  }
}
inline ::milvus::grpc::BooleanQuery* GeneralQuery::release_boolean_query() {
  // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.boolean_query)
  if (has_boolean_query()) {
    clear_has_query();
      ::milvus::grpc::BooleanQuery* temp = query_.boolean_query_;
    query_.boolean_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::grpc::BooleanQuery& GeneralQuery::boolean_query() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.boolean_query)
  return has_boolean_query()
      ? *query_.boolean_query_
      : *reinterpret_cast< ::milvus::grpc::BooleanQuery*>(&::milvus::grpc::_BooleanQuery_default_instance_);
}
inline ::milvus::grpc::BooleanQuery* GeneralQuery::mutable_boolean_query() {
  if (!has_boolean_query()) {
    clear_query();
    set_has_boolean_query();
    query_.boolean_query_ = CreateMaybeMessage< ::milvus::grpc::BooleanQuery >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.boolean_query)
  return query_.boolean_query_;
}

// .milvus.grpc.TermQuery term_query = 2;
inline bool GeneralQuery::has_term_query() const {
  return query_case() == kTermQuery;
}
inline void GeneralQuery::set_has_term_query() {
  _oneof_case_[0] = kTermQuery;
}
inline void GeneralQuery::clear_term_query() {
  if (has_term_query()) {
    delete query_.term_query_;
    clear_has_query();
  }
}
inline ::milvus::grpc::TermQuery* GeneralQuery::release_term_query() {
  // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.term_query)
  if (has_term_query()) {
    clear_has_query();
      ::milvus::grpc::TermQuery* temp = query_.term_query_;
    query_.term_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::grpc::TermQuery& GeneralQuery::term_query() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.term_query)
  return has_term_query()
      ? *query_.term_query_
      : *reinterpret_cast< ::milvus::grpc::TermQuery*>(&::milvus::grpc::_TermQuery_default_instance_);
}
inline ::milvus::grpc::TermQuery* GeneralQuery::mutable_term_query() {
  if (!has_term_query()) {
    clear_query();
    set_has_term_query();
    query_.term_query_ = CreateMaybeMessage< ::milvus::grpc::TermQuery >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.term_query)
  return query_.term_query_;
}

// .milvus.grpc.RangeQuery range_query = 3;
inline bool GeneralQuery::has_range_query() const {
  return query_case() == kRangeQuery;
}
inline void GeneralQuery::set_has_range_query() {
  _oneof_case_[0] = kRangeQuery;
}
inline void GeneralQuery::clear_range_query() {
  if (has_range_query()) {
    delete query_.range_query_;
    clear_has_query();
  }
}
inline ::milvus::grpc::RangeQuery* GeneralQuery::release_range_query() {
  // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.range_query)
  if (has_range_query()) {
    clear_has_query();
      ::milvus::grpc::RangeQuery* temp = query_.range_query_;
    query_.range_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::grpc::RangeQuery& GeneralQuery::range_query() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.range_query)
  return has_range_query()
      ? *query_.range_query_
      : *reinterpret_cast< ::milvus::grpc::RangeQuery*>(&::milvus::grpc::_RangeQuery_default_instance_);
}
inline ::milvus::grpc::RangeQuery* GeneralQuery::mutable_range_query() {
  if (!has_range_query()) {
    clear_query();
    set_has_range_query();
    query_.range_query_ = CreateMaybeMessage< ::milvus::grpc::RangeQuery >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.range_query)
  return query_.range_query_;
}

// .milvus.grpc.VectorQuery vector_query = 4;
inline bool GeneralQuery::has_vector_query() const {
  return query_case() == kVectorQuery;
}
inline void GeneralQuery::set_has_vector_query() {
  _oneof_case_[0] = kVectorQuery;
}
inline void GeneralQuery::clear_vector_query() {
  if (has_vector_query()) {
    delete query_.vector_query_;
    clear_has_query();
  }
}
inline ::milvus::grpc::VectorQuery* GeneralQuery::release_vector_query() {
  // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.vector_query)
  if (has_vector_query()) {
    clear_has_query();
      ::milvus::grpc::VectorQuery* temp = query_.vector_query_;
    query_.vector_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::grpc::VectorQuery& GeneralQuery::vector_query() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.vector_query)
  return has_vector_query()
      ? *query_.vector_query_
      : *reinterpret_cast< ::milvus::grpc::VectorQuery*>(&::milvus::grpc::_VectorQuery_default_instance_);
}
inline ::milvus::grpc::VectorQuery* GeneralQuery::mutable_vector_query() {
  if (!has_vector_query()) {
    clear_query();
    set_has_vector_query();
    query_.vector_query_ = CreateMaybeMessage< ::milvus::grpc::VectorQuery >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.vector_query)
  return query_.vector_query_;
}

inline bool GeneralQuery::has_query() const {
  return query_case() != QUERY_NOT_SET;
}
inline void GeneralQuery::clear_has_query() {
  _oneof_case_[0] = QUERY_NOT_SET;
}
inline GeneralQuery::QueryCase GeneralQuery::query_case() const {
  return GeneralQuery::QueryCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// SearchParamPB

// string collection_name = 1;
inline void SearchParamPB::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchParamPB::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.collection_name)
  return collection_name_.GetNoArena();
}
inline void SearchParamPB::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParamPB.collection_name)
}
inline void SearchParamPB::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParamPB.collection_name)
}
inline void SearchParamPB::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.grpc.SearchParamPB.collection_name)
}
inline void SearchParamPB::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.grpc.SearchParamPB.collection_name)
}
inline std::string* SearchParamPB::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchParamPB::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchParamPB.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchParamPB::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.grpc.SearchParamPB.collection_name)
}

// repeated string partition_tag_array = 2;
inline int SearchParamPB::partition_tag_array_size() const {
  return partition_tag_array_.size();
}
inline void SearchParamPB::clear_partition_tag_array() {
  partition_tag_array_.Clear();
}
inline const std::string& SearchParamPB::partition_tag_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.partition_tag_array)
  return partition_tag_array_.Get(index);
}
inline std::string* SearchParamPB::mutable_partition_tag_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.partition_tag_array)
  return partition_tag_array_.Mutable(index);
}
inline void SearchParamPB::set_partition_tag_array(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParamPB.partition_tag_array)
  partition_tag_array_.Mutable(index)->assign(value);
}
inline void SearchParamPB::set_partition_tag_array(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParamPB.partition_tag_array)
  partition_tag_array_.Mutable(index)->assign(std::move(value));
}
inline void SearchParamPB::set_partition_tag_array(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_array_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParamPB.partition_tag_array)
}
inline void SearchParamPB::set_partition_tag_array(int index, const char* value, size_t size) {
  partition_tag_array_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParamPB.partition_tag_array)
}
inline std::string* SearchParamPB::add_partition_tag_array() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchParamPB.partition_tag_array)
  return partition_tag_array_.Add();
}
inline void SearchParamPB::add_partition_tag_array(const std::string& value) {
  partition_tag_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParamPB.partition_tag_array)
}
inline void SearchParamPB::add_partition_tag_array(std::string&& value) {
  partition_tag_array_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParamPB.partition_tag_array)
}
inline void SearchParamPB::add_partition_tag_array(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchParamPB.partition_tag_array)
}
inline void SearchParamPB::add_partition_tag_array(const char* value, size_t size) {
  partition_tag_array_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchParamPB.partition_tag_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchParamPB::partition_tag_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParamPB.partition_tag_array)
  return partition_tag_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchParamPB::mutable_partition_tag_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParamPB.partition_tag_array)
  return &partition_tag_array_;
}

// .milvus.grpc.GeneralQuery general_query = 3;
inline bool SearchParamPB::has_general_query() const {
  return this != internal_default_instance() && general_query_ != nullptr;
}
inline void SearchParamPB::clear_general_query() {
  if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) {
    delete general_query_;
  }
  general_query_ = nullptr;
}
inline const ::milvus::grpc::GeneralQuery& SearchParamPB::general_query() const {
  const ::milvus::grpc::GeneralQuery* p = general_query_;
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.general_query)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::GeneralQuery*>(
      &::milvus::grpc::_GeneralQuery_default_instance_);
}
inline ::milvus::grpc::GeneralQuery* SearchParamPB::release_general_query() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchParamPB.general_query)
  
  ::milvus::grpc::GeneralQuery* temp = general_query_;
  general_query_ = nullptr;
  return temp;
}
inline ::milvus::grpc::GeneralQuery* SearchParamPB::mutable_general_query() {
  
  if (general_query_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::GeneralQuery>(GetArenaNoVirtual());
    general_query_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.general_query)
  return general_query_;
}
inline void SearchParamPB::set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete general_query_;
  }
  if (general_query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      general_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, general_query, submessage_arena);
    }
    
  } else {
    
  }
  general_query_ = general_query;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParamPB.general_query)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 4;
inline int SearchParamPB::extra_params_size() const {
  return extra_params_.size();
}
inline void SearchParamPB::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* SearchParamPB::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
SearchParamPB::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParamPB.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& SearchParamPB::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* SearchParamPB::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParamPB.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
SearchParamPB::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParamPB.extra_params)
  return extra_params_;
}

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

// InsertOrDeleteMsg

// string collection_name = 1;
inline void InsertOrDeleteMsg::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& InsertOrDeleteMsg::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.collection_name)
  return collection_name_.GetNoArena();
}
inline void InsertOrDeleteMsg::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.collection_name)
}
inline void InsertOrDeleteMsg::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertOrDeleteMsg.collection_name)
}
inline void InsertOrDeleteMsg::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.grpc.InsertOrDeleteMsg.collection_name)
}
inline void InsertOrDeleteMsg::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.grpc.InsertOrDeleteMsg.collection_name)
}
inline std::string* InsertOrDeleteMsg::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* InsertOrDeleteMsg::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertOrDeleteMsg.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void InsertOrDeleteMsg::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.grpc.InsertOrDeleteMsg.collection_name)
}

// .milvus.grpc.RowData rows_data = 2;
inline bool InsertOrDeleteMsg::has_rows_data() const {
  return this != internal_default_instance() && rows_data_ != nullptr;
}
inline void InsertOrDeleteMsg::clear_rows_data() {
  if (GetArenaNoVirtual() == nullptr && rows_data_ != nullptr) {
    delete rows_data_;
  }
  rows_data_ = nullptr;
}
inline const ::milvus::grpc::RowData& InsertOrDeleteMsg::rows_data() const {
  const ::milvus::grpc::RowData* p = rows_data_;
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.rows_data)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::RowData*>(
      &::milvus::grpc::_RowData_default_instance_);
}
inline ::milvus::grpc::RowData* InsertOrDeleteMsg::release_rows_data() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertOrDeleteMsg.rows_data)
  
  ::milvus::grpc::RowData* temp = rows_data_;
  rows_data_ = nullptr;
  return temp;
}
inline ::milvus::grpc::RowData* InsertOrDeleteMsg::mutable_rows_data() {
  
  if (rows_data_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::RowData>(GetArenaNoVirtual());
    rows_data_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.rows_data)
  return rows_data_;
}
inline void InsertOrDeleteMsg::set_allocated_rows_data(::milvus::grpc::RowData* rows_data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete rows_data_;
  }
  if (rows_data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      rows_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rows_data, submessage_arena);
    }
    
  } else {
    
  }
  rows_data_ = rows_data;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertOrDeleteMsg.rows_data)
}

// int64 uid = 3;
inline void InsertOrDeleteMsg::clear_uid() {
  uid_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::uid() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.uid)
  return uid_;
}
inline void InsertOrDeleteMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  uid_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.uid)
}

// string partition_tag = 4;
inline void InsertOrDeleteMsg::clear_partition_tag() {
  partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& InsertOrDeleteMsg::partition_tag() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.partition_tag)
  return partition_tag_.GetNoArena();
}
inline void InsertOrDeleteMsg::set_partition_tag(const std::string& value) {
  
  partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.partition_tag)
}
inline void InsertOrDeleteMsg::set_partition_tag(std::string&& value) {
  
  partition_tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertOrDeleteMsg.partition_tag)
}
inline void InsertOrDeleteMsg::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.grpc.InsertOrDeleteMsg.partition_tag)
}
inline void InsertOrDeleteMsg::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.grpc.InsertOrDeleteMsg.partition_tag)
}
inline std::string* InsertOrDeleteMsg::mutable_partition_tag() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.partition_tag)
  return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* InsertOrDeleteMsg::release_partition_tag() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertOrDeleteMsg.partition_tag)
  
  return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void InsertOrDeleteMsg::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.grpc.InsertOrDeleteMsg.partition_tag)
}

// uint64 timestamp = 5;
inline void InsertOrDeleteMsg::clear_timestamp() {
  timestamp_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 InsertOrDeleteMsg::timestamp() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.timestamp)
  return timestamp_;
}
inline void InsertOrDeleteMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.timestamp)
}

// int64 segment_id = 6;
inline void InsertOrDeleteMsg::clear_segment_id() {
  segment_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::segment_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.segment_id)
  return segment_id_;
}
inline void InsertOrDeleteMsg::set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  segment_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.segment_id)
}

// int64 channel_id = 7;
inline void InsertOrDeleteMsg::clear_channel_id() {
  channel_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::channel_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.channel_id)
  return channel_id_;
}
inline void InsertOrDeleteMsg::set_channel_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  channel_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.channel_id)
}

// .milvus.grpc.OpType op = 8;
inline void InsertOrDeleteMsg::clear_op() {
  op_ = 0;
}
inline ::milvus::grpc::OpType InsertOrDeleteMsg::op() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.op)
  return static_cast< ::milvus::grpc::OpType >(op_);
}
inline void InsertOrDeleteMsg::set_op(::milvus::grpc::OpType value) {
  
  op_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.op)
}

// int64 client_id = 9;
inline void InsertOrDeleteMsg::clear_client_id() {
  client_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::client_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.client_id)
  return client_id_;
}
inline void InsertOrDeleteMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  client_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.client_id)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 10;
inline int InsertOrDeleteMsg::extra_params_size() const {
  return extra_params_.size();
}
inline void InsertOrDeleteMsg::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* InsertOrDeleteMsg::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
InsertOrDeleteMsg::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertOrDeleteMsg.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& InsertOrDeleteMsg::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* InsertOrDeleteMsg::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.InsertOrDeleteMsg.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
InsertOrDeleteMsg::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.InsertOrDeleteMsg.extra_params)
  return extra_params_;
}

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

// SearchMsg

// string collection_name = 1;
inline void SearchMsg::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchMsg::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.collection_name)
  return collection_name_.GetNoArena();
}
inline void SearchMsg::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.collection_name)
}
inline void SearchMsg::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchMsg.collection_name)
}
inline void SearchMsg::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.grpc.SearchMsg.collection_name)
}
inline void SearchMsg::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.grpc.SearchMsg.collection_name)
}
inline std::string* SearchMsg::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchMsg::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchMsg::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.grpc.SearchMsg.collection_name)
}

// .milvus.grpc.VectorRowRecord records = 2;
inline bool SearchMsg::has_records() const {
  return this != internal_default_instance() && records_ != nullptr;
}
inline void SearchMsg::clear_records() {
  if (GetArenaNoVirtual() == nullptr && records_ != nullptr) {
    delete records_;
  }
  records_ = nullptr;
}
inline const ::milvus::grpc::VectorRowRecord& SearchMsg::records() const {
  const ::milvus::grpc::VectorRowRecord* p = records_;
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.records)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::VectorRowRecord*>(
      &::milvus::grpc::_VectorRowRecord_default_instance_);
}
inline ::milvus::grpc::VectorRowRecord* SearchMsg::release_records() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.records)
  
  ::milvus::grpc::VectorRowRecord* temp = records_;
  records_ = nullptr;
  return temp;
}
inline ::milvus::grpc::VectorRowRecord* SearchMsg::mutable_records() {
  
  if (records_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::VectorRowRecord>(GetArenaNoVirtual());
    records_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.records)
  return records_;
}
inline void SearchMsg::set_allocated_records(::milvus::grpc::VectorRowRecord* records) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete records_;
  }
  if (records) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      records = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, records, submessage_arena);
    }
    
  } else {
    
  }
  records_ = records;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.records)
}

// repeated string partition_tag = 3;
inline int SearchMsg::partition_tag_size() const {
  return partition_tag_.size();
}
inline void SearchMsg::clear_partition_tag() {
  partition_tag_.Clear();
}
inline const std::string& SearchMsg::partition_tag(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.partition_tag)
  return partition_tag_.Get(index);
}
inline std::string* SearchMsg::mutable_partition_tag(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.partition_tag)
  return partition_tag_.Mutable(index);
}
inline void SearchMsg::set_partition_tag(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag)
  partition_tag_.Mutable(index)->assign(value);
}
inline void SearchMsg::set_partition_tag(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag)
  partition_tag_.Mutable(index)->assign(std::move(value));
}
inline void SearchMsg::set_partition_tag(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.partition_tag)
}
inline void SearchMsg::set_partition_tag(int index, const char* value, size_t size) {
  partition_tag_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.partition_tag)
}
inline std::string* SearchMsg::add_partition_tag() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchMsg.partition_tag)
  return partition_tag_.Add();
}
inline void SearchMsg::add_partition_tag(const std::string& value) {
  partition_tag_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.partition_tag)
}
inline void SearchMsg::add_partition_tag(std::string&& value) {
  partition_tag_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.partition_tag)
}
inline void SearchMsg::add_partition_tag(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tag_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchMsg.partition_tag)
}
inline void SearchMsg::add_partition_tag(const char* value, size_t size) {
  partition_tag_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchMsg.partition_tag)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchMsg::partition_tag() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.partition_tag)
  return partition_tag_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchMsg::mutable_partition_tag() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.partition_tag)
  return &partition_tag_;
}

// int64 uid = 4;
inline void SearchMsg::clear_uid() {
  uid_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SearchMsg::uid() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.uid)
  return uid_;
}
inline void SearchMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  uid_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.uid)
}

// uint64 timestamp = 5;
inline void SearchMsg::clear_timestamp() {
  timestamp_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 SearchMsg::timestamp() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.timestamp)
  return timestamp_;
}
inline void SearchMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.timestamp)
}

// int64 client_id = 6;
inline void SearchMsg::clear_client_id() {
  client_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SearchMsg::client_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.client_id)
  return client_id_;
}
inline void SearchMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  client_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.client_id)
}

// repeated .milvus.grpc.KeyValuePair extra_params = 7;
inline int SearchMsg::extra_params_size() const {
  return extra_params_.size();
}
inline void SearchMsg::clear_extra_params() {
  extra_params_.Clear();
}
inline ::milvus::grpc::KeyValuePair* SearchMsg::mutable_extra_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.extra_params)
  return extra_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
SearchMsg::mutable_extra_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.extra_params)
  return &extra_params_;
}
inline const ::milvus::grpc::KeyValuePair& SearchMsg::extra_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.extra_params)
  return extra_params_.Get(index);
}
inline ::milvus::grpc::KeyValuePair* SearchMsg::add_extra_params() {
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.extra_params)
  return extra_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
SearchMsg::extra_params() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.extra_params)
  return extra_params_;
}

// repeated string json = 8;
inline int SearchMsg::json_size() const {
  return json_.size();
}
inline void SearchMsg::clear_json() {
  json_.Clear();
}
inline const std::string& SearchMsg::json(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.json)
  return json_.Get(index);
}
inline std::string* SearchMsg::mutable_json(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.json)
  return json_.Mutable(index);
}
inline void SearchMsg::set_json(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.json)
  json_.Mutable(index)->assign(value);
}
inline void SearchMsg::set_json(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.json)
  json_.Mutable(index)->assign(std::move(value));
}
inline void SearchMsg::set_json(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  json_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::set_json(int index, const char* value, size_t size) {
  json_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.json)
}
inline std::string* SearchMsg::add_json() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchMsg.json)
  return json_.Add();
}
inline void SearchMsg::add_json(const std::string& value) {
  json_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::add_json(std::string&& value) {
  json_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::add_json(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  json_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::add_json(const char* value, size_t size) {
  json_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchMsg.json)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchMsg::json() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.json)
  return json_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchMsg::mutable_json() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.json)
  return &json_;
}

// string dsl = 9;
inline void SearchMsg::clear_dsl() {
  dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchMsg::dsl() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.dsl)
  return dsl_.GetNoArena();
}
inline void SearchMsg::set_dsl(const std::string& value) {
  
  dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.dsl)
}
inline void SearchMsg::set_dsl(std::string&& value) {
  
  dsl_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchMsg.dsl)
}
inline void SearchMsg::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.grpc.SearchMsg.dsl)
}
inline void SearchMsg::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.grpc.SearchMsg.dsl)
}
inline std::string* SearchMsg::mutable_dsl() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.dsl)
  return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchMsg::release_dsl() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.dsl)
  
  return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchMsg::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.grpc.SearchMsg.dsl)
}

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

// TimeSyncMsg

// int64 peer_Id = 1;
inline void TimeSyncMsg::clear_peer_id() {
  peer_id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TimeSyncMsg::peer_id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TimeSyncMsg.peer_Id)
  return peer_id_;
}
inline void TimeSyncMsg::set_peer_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  peer_id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TimeSyncMsg.peer_Id)
}

// uint64 Timestamp = 2;
inline void TimeSyncMsg::clear_timestamp() {
  timestamp_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TimeSyncMsg::timestamp() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TimeSyncMsg.Timestamp)
  return timestamp_;
}
inline void TimeSyncMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TimeSyncMsg.Timestamp)
}

// .milvus.grpc.SyncType sync_type = 3;
inline void TimeSyncMsg::clear_sync_type() {
  sync_type_ = 0;
}
inline ::milvus::grpc::SyncType TimeSyncMsg::sync_type() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TimeSyncMsg.sync_type)
  return static_cast< ::milvus::grpc::SyncType >(sync_type_);
}
inline void TimeSyncMsg::set_sync_type(::milvus::grpc::SyncType value) {
  
  sync_type_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TimeSyncMsg.sync_type)
}

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

// Key2SegMsg

// int64 uid = 1;
inline void Key2SegMsg::clear_uid() {
  uid_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Key2SegMsg::uid() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.uid)
  return uid_;
}
inline void Key2SegMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  uid_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.uid)
}

// uint64 timestamp = 2;
inline void Key2SegMsg::clear_timestamp() {
  timestamp_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Key2SegMsg::timestamp() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.timestamp)
  return timestamp_;
}
inline void Key2SegMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.timestamp)
}

// repeated int64 segment_id = 3;
inline int Key2SegMsg::segment_id_size() const {
  return segment_id_.size();
}
inline void Key2SegMsg::clear_segment_id() {
  segment_id_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Key2SegMsg::segment_id(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.segment_id)
  return segment_id_.Get(index);
}
inline void Key2SegMsg::set_segment_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  segment_id_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.segment_id)
}
inline void Key2SegMsg::add_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  segment_id_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.Key2SegMsg.segment_id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
Key2SegMsg::segment_id() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.Key2SegMsg.segment_id)
  return segment_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
Key2SegMsg::mutable_segment_id() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Key2SegMsg.segment_id)
  return &segment_id_;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace grpc
}  // namespace milvus

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::milvus::grpc::ErrorCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::ErrorCode>() {
  return ::milvus::grpc::ErrorCode_descriptor();
}
template <> struct is_proto_enum< ::milvus::grpc::DataType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::DataType>() {
  return ::milvus::grpc::DataType_descriptor();
}
template <> struct is_proto_enum< ::milvus::grpc::CompareOperator> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::CompareOperator>() {
  return ::milvus::grpc::CompareOperator_descriptor();
}
template <> struct is_proto_enum< ::milvus::grpc::Occur> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::Occur>() {
  return ::milvus::grpc::Occur_descriptor();
}
template <> struct is_proto_enum< ::milvus::grpc::OpType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::OpType>() {
  return ::milvus::grpc::OpType_descriptor();
}
template <> struct is_proto_enum< ::milvus::grpc::SyncType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::SyncType>() {
  return ::milvus::grpc::SyncType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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