text: // 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[49]
      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 ManipulationReqMsg;
  class ManipulationReqMsgDefaultTypeInternal;
  extern ManipulationReqMsgDefaultTypeInternal _ManipulationReqMsg_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 QueryReqMsg;
  class QueryReqMsgDefaultTypeInternal;
  extern QueryReqMsgDefaultTypeInternal _QueryReqMsg_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::ManipulationReqMsg* Arena::CreateMaybeMessage<::milvus::grpc::ManipulationReqMsg>(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::QueryReqMsg* Arena::CreateMaybeMessage<::milvus::grpc::QueryReqMsg>(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 ReqType : int {
    kCmd = 0,
    kCreateCollection = 100,
    kDropCollection = 101,
    kHasCollection = 102,
    kListCollections = 103,
    kGetCollectionInfo = 104,
    kGetCollectionStats = 105,
    kCountEntities = 106,
    kCreatePartition = 200,
    kDropPartition = 201,
    kHasPartition = 202,
    kListPartitions = 203,
    kCreateIndex = 300,
    kDropIndex = 301,
    kDescribeIndex = 302,
    kInsert = 400,
    kGetEntityByID = 401,
    kDeleteEntityByID = 402,
    kSearch = 403,
    kListIDInSegment = 404,
    kLoadCollection = 500,
    kFlush = 501,
    kCompact = 502,
    ReqType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    ReqType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool ReqType_IsValid(int value);
  constexpr ReqType ReqType_MIN = kCmd;
  constexpr ReqType ReqType_MAX = kCompact;
  constexpr int ReqType_ARRAYSIZE = ReqType_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReqType_descriptor();
  template<typename T>
  inline const std::string& ReqType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ReqType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ReqType_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      ReqType_descriptor(), enum_t_value);
  }
  inline bool ReqType_Parse(
      const std::string& name, ReqType* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReqType>(
      ReqType_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,
      kProxyIdFieldNumber = 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 proxy_id = 8;
    void clear_proxy_id();
    ::PROTOBUF_NAMESPACE_ID::int64 proxy_id() const;
    void set_proxy_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 proxy_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);
  
    // int64 id = 1;
    void clear_id();
    ::PROTOBUF_NAMESPACE_ID::int64 id() const;
    void set_id(::PROTOBUF_NAMESPACE_ID::int64 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::int64 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 QueryReqMsg :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.QueryReqMsg) */ {
   public:
    QueryReqMsg();
    virtual ~QueryReqMsg();
  
    QueryReqMsg(const QueryReqMsg& from);
    QueryReqMsg(QueryReqMsg&& from) noexcept
      : QueryReqMsg() {
      *this = ::std::move(from);
    }
  
    inline QueryReqMsg& operator=(const QueryReqMsg& from) {
      CopyFrom(from);
      return *this;
    }
    inline QueryReqMsg& operator=(QueryReqMsg&& 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 QueryReqMsg& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const QueryReqMsg* internal_default_instance() {
      return reinterpret_cast<const QueryReqMsg*>(
                 &_QueryReqMsg_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      43;
  
    friend void swap(QueryReqMsg& a, QueryReqMsg& b) {
      a.Swap(&b);
    }
    inline void Swap(QueryReqMsg* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline QueryReqMsg* New() const final {
      return CreateMaybeMessage<QueryReqMsg>(nullptr);
    }
  
    QueryReqMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<QueryReqMsg>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const QueryReqMsg& from);
    void MergeFrom(const QueryReqMsg& 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(QueryReqMsg* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.grpc.QueryReqMsg";
    }
    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,
      kPartitionTagsFieldNumber = 3,
      kExtraParamsFieldNumber = 5,
      kCollectionNameFieldNumber = 1,
      kDslFieldNumber = 4,
      kTimestampFieldNumber = 6,
      kProxyIdFieldNumber = 7,
      kQueryIdFieldNumber = 8,
      kReqTypeFieldNumber = 9,
    };
    // 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_tags = 3;
    int partition_tags_size() const;
    void clear_partition_tags();
    const std::string& partition_tags(int index) const;
    std::string* mutable_partition_tags(int index);
    void set_partition_tags(int index, const std::string& value);
    void set_partition_tags(int index, std::string&& value);
    void set_partition_tags(int index, const char* value);
    void set_partition_tags(int index, const char* value, size_t size);
    std::string* add_partition_tags();
    void add_partition_tags(const std::string& value);
    void add_partition_tags(std::string&& value);
    void add_partition_tags(const char* value);
    void add_partition_tags(const char* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tags() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tags();
  
    // 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 = 4;
    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);
  
    // uint64 timestamp = 6;
    void clear_timestamp();
    ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
    void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);
  
    // int64 proxy_id = 7;
    void clear_proxy_id();
    ::PROTOBUF_NAMESPACE_ID::int64 proxy_id() const;
    void set_proxy_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  
    // int64 query_id = 8;
    void clear_query_id();
    ::PROTOBUF_NAMESPACE_ID::int64 query_id() const;
    void set_query_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  
    // .milvus.grpc.ReqType req_type = 9;
    void clear_req_type();
    ::milvus::grpc::ReqType req_type() const;
    void set_req_type(::milvus::grpc::ReqType value);
  
    // @@protoc_insertion_point(class_scope:milvus.grpc.QueryReqMsg)
   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_tags_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_;
    ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
    ::PROTOBUF_NAMESPACE_ID::int64 proxy_id_;
    ::PROTOBUF_NAMESPACE_ID::int64 query_id_;
    int req_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_message_2eproto;
  };
  // -------------------------------------------------------------------
  
  class ManipulationReqMsg :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.ManipulationReqMsg) */ {
   public:
    ManipulationReqMsg();
    virtual ~ManipulationReqMsg();
  
    ManipulationReqMsg(const ManipulationReqMsg& from);
    ManipulationReqMsg(ManipulationReqMsg&& from) noexcept
      : ManipulationReqMsg() {
      *this = ::std::move(from);
    }
  
    inline ManipulationReqMsg& operator=(const ManipulationReqMsg& from) {
      CopyFrom(from);
      return *this;
    }
    inline ManipulationReqMsg& operator=(ManipulationReqMsg&& 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 ManipulationReqMsg& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const ManipulationReqMsg* internal_default_instance() {
      return reinterpret_cast<const ManipulationReqMsg*>(
                 &_ManipulationReqMsg_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      44;
  
    friend void swap(ManipulationReqMsg& a, ManipulationReqMsg& b) {
      a.Swap(&b);
    }
    inline void Swap(ManipulationReqMsg* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline ManipulationReqMsg* New() const final {
      return CreateMaybeMessage<ManipulationReqMsg>(nullptr);
    }
  
    ManipulationReqMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<ManipulationReqMsg>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const ManipulationReqMsg& from);
    void MergeFrom(const ManipulationReqMsg& 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(ManipulationReqMsg* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.grpc.ManipulationReqMsg";
    }
    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 {
      kPrimaryKeysFieldNumber = 3,
      kRowsDataFieldNumber = 4,
      kExtraParamsFieldNumber = 10,
      kCollectionNameFieldNumber = 1,
      kPartitionTagFieldNumber = 2,
      kTimestampFieldNumber = 5,
      kSegmentIdFieldNumber = 6,
      kChannelIdFieldNumber = 7,
      kProxyIdFieldNumber = 9,
      kReqTypeFieldNumber = 8,
    };
    // repeated int64 primary_keys = 3;
    int primary_keys_size() const;
    void clear_primary_keys();
    ::PROTOBUF_NAMESPACE_ID::int64 primary_keys(int index) const;
    void set_primary_keys(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
    void add_primary_keys(::PROTOBUF_NAMESPACE_ID::int64 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        primary_keys() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        mutable_primary_keys();
  
    // 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;
  
    // 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 = 2;
    void clear_partition_tag();
    const std::string& partition_tag() const;
    void set_partition_tag(const std::string& value);
    void set_partition_tag(std::string&& value);
    void set_partition_tag(const char* value);
    void set_partition_tag(const char* value, size_t size);
    std::string* mutable_partition_tag();
    std::string* release_partition_tag();
    void set_allocated_partition_tag(std::string* partition_tag);
  
    // 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 proxy_id = 9;
    void clear_proxy_id();
    ::PROTOBUF_NAMESPACE_ID::int64 proxy_id() const;
    void set_proxy_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  
    // .milvus.grpc.ReqType req_type = 8;
    void clear_req_type();
    ::milvus::grpc::ReqType req_type() const;
    void set_req_type(::milvus::grpc::ReqType value);
  
    // @@protoc_insertion_point(class_scope:milvus.grpc.ManipulationReqMsg)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > primary_keys_;
    mutable std::atomic<int> _primary_keys_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData > rows_data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_;
    ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
    ::PROTOBUF_NAMESPACE_ID::int64 segment_id_;
    ::PROTOBUF_NAMESPACE_ID::int64 channel_id_;
    ::PROTOBUF_NAMESPACE_ID::int64 proxy_id_;
    int req_type_;
    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 =
      45;
  
    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 =
      46;
  
    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 =
      47;
  
    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 =
      48;
  
    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 proxy_id = 8;
  inline void QueryResult::clear_proxy_id() {
    proxy_id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::proxy_id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.proxy_id)
    return proxy_id_;
  }
  inline void QueryResult::set_proxy_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    proxy_id_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.proxy_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
  
  // int64 id = 1;
  inline void FieldParam::clear_id() {
    id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 FieldParam::id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.id)
    return id_;
  }
  inline void FieldParam::set_id(::PROTOBUF_NAMESPACE_ID::int64 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_;
  }
  
  // -------------------------------------------------------------------
  
  // QueryReqMsg
  
  // string collection_name = 1;
  inline void QueryReqMsg::clear_collection_name() {
    collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& QueryReqMsg::collection_name() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.collection_name)
    return collection_name_.GetNoArena();
  }
  inline void QueryReqMsg::set_collection_name(const std::string& value) {
    
    collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.collection_name)
  }
  inline void QueryReqMsg::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.QueryReqMsg.collection_name)
  }
  inline void QueryReqMsg::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.QueryReqMsg.collection_name)
  }
  inline void QueryReqMsg::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.QueryReqMsg.collection_name)
  }
  inline std::string* QueryReqMsg::mutable_collection_name() {
    
    // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryReqMsg.collection_name)
    return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* QueryReqMsg::release_collection_name() {
    // @@protoc_insertion_point(field_release:milvus.grpc.QueryReqMsg.collection_name)
    
    return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void QueryReqMsg::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.QueryReqMsg.collection_name)
  }
  
  // repeated .milvus.grpc.VectorParam vector_param = 2;
  inline int QueryReqMsg::vector_param_size() const {
    return vector_param_.size();
  }
  inline void QueryReqMsg::clear_vector_param() {
    vector_param_.Clear();
  }
  inline ::milvus::grpc::VectorParam* QueryReqMsg::mutable_vector_param(int index) {
    // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryReqMsg.vector_param)
    return vector_param_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >*
  QueryReqMsg::mutable_vector_param() {
    // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryReqMsg.vector_param)
    return &vector_param_;
  }
  inline const ::milvus::grpc::VectorParam& QueryReqMsg::vector_param(int index) const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.vector_param)
    return vector_param_.Get(index);
  }
  inline ::milvus::grpc::VectorParam* QueryReqMsg::add_vector_param() {
    // @@protoc_insertion_point(field_add:milvus.grpc.QueryReqMsg.vector_param)
    return vector_param_.Add();
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >&
  QueryReqMsg::vector_param() const {
    // @@protoc_insertion_point(field_list:milvus.grpc.QueryReqMsg.vector_param)
    return vector_param_;
  }
  
  // repeated string partition_tags = 3;
  inline int QueryReqMsg::partition_tags_size() const {
    return partition_tags_.size();
  }
  inline void QueryReqMsg::clear_partition_tags() {
    partition_tags_.Clear();
  }
  inline const std::string& QueryReqMsg::partition_tags(int index) const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.partition_tags)
    return partition_tags_.Get(index);
  }
  inline std::string* QueryReqMsg::mutable_partition_tags(int index) {
    // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryReqMsg.partition_tags)
    return partition_tags_.Mutable(index);
  }
  inline void QueryReqMsg::set_partition_tags(int index, const std::string& value) {
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.partition_tags)
    partition_tags_.Mutable(index)->assign(value);
  }
  inline void QueryReqMsg::set_partition_tags(int index, std::string&& value) {
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.partition_tags)
    partition_tags_.Mutable(index)->assign(std::move(value));
  }
  inline void QueryReqMsg::set_partition_tags(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    partition_tags_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:milvus.grpc.QueryReqMsg.partition_tags)
  }
  inline void QueryReqMsg::set_partition_tags(int index, const char* value, size_t size) {
    partition_tags_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:milvus.grpc.QueryReqMsg.partition_tags)
  }
  inline std::string* QueryReqMsg::add_partition_tags() {
    // @@protoc_insertion_point(field_add_mutable:milvus.grpc.QueryReqMsg.partition_tags)
    return partition_tags_.Add();
  }
  inline void QueryReqMsg::add_partition_tags(const std::string& value) {
    partition_tags_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:milvus.grpc.QueryReqMsg.partition_tags)
  }
  inline void QueryReqMsg::add_partition_tags(std::string&& value) {
    partition_tags_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:milvus.grpc.QueryReqMsg.partition_tags)
  }
  inline void QueryReqMsg::add_partition_tags(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    partition_tags_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:milvus.grpc.QueryReqMsg.partition_tags)
  }
  inline void QueryReqMsg::add_partition_tags(const char* value, size_t size) {
    partition_tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:milvus.grpc.QueryReqMsg.partition_tags)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  QueryReqMsg::partition_tags() const {
    // @@protoc_insertion_point(field_list:milvus.grpc.QueryReqMsg.partition_tags)
    return partition_tags_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  QueryReqMsg::mutable_partition_tags() {
    // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryReqMsg.partition_tags)
    return &partition_tags_;
  }
  
  // string dsl = 4;
  inline void QueryReqMsg::clear_dsl() {
    dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& QueryReqMsg::dsl() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.dsl)
    return dsl_.GetNoArena();
  }
  inline void QueryReqMsg::set_dsl(const std::string& value) {
    
    dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.dsl)
  }
  inline void QueryReqMsg::set_dsl(std::string&& value) {
    
    dsl_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.QueryReqMsg.dsl)
  }
  inline void QueryReqMsg::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.QueryReqMsg.dsl)
  }
  inline void QueryReqMsg::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.QueryReqMsg.dsl)
  }
  inline std::string* QueryReqMsg::mutable_dsl() {
    
    // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryReqMsg.dsl)
    return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* QueryReqMsg::release_dsl() {
    // @@protoc_insertion_point(field_release:milvus.grpc.QueryReqMsg.dsl)
    
    return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void QueryReqMsg::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.QueryReqMsg.dsl)
  }
  
  // repeated .milvus.grpc.KeyValuePair extra_params = 5;
  inline int QueryReqMsg::extra_params_size() const {
    return extra_params_.size();
  }
  inline void QueryReqMsg::clear_extra_params() {
    extra_params_.Clear();
  }
  inline ::milvus::grpc::KeyValuePair* QueryReqMsg::mutable_extra_params(int index) {
    // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryReqMsg.extra_params)
    return extra_params_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
  QueryReqMsg::mutable_extra_params() {
    // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryReqMsg.extra_params)
    return &extra_params_;
  }
  inline const ::milvus::grpc::KeyValuePair& QueryReqMsg::extra_params(int index) const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.extra_params)
    return extra_params_.Get(index);
  }
  inline ::milvus::grpc::KeyValuePair* QueryReqMsg::add_extra_params() {
    // @@protoc_insertion_point(field_add:milvus.grpc.QueryReqMsg.extra_params)
    return extra_params_.Add();
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
  QueryReqMsg::extra_params() const {
    // @@protoc_insertion_point(field_list:milvus.grpc.QueryReqMsg.extra_params)
    return extra_params_;
  }
  
  // uint64 timestamp = 6;
  inline void QueryReqMsg::clear_timestamp() {
    timestamp_ = PROTOBUF_ULONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 QueryReqMsg::timestamp() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.timestamp)
    return timestamp_;
  }
  inline void QueryReqMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    timestamp_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.timestamp)
  }
  
  // int64 proxy_id = 7;
  inline void QueryReqMsg::clear_proxy_id() {
    proxy_id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 QueryReqMsg::proxy_id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.proxy_id)
    return proxy_id_;
  }
  inline void QueryReqMsg::set_proxy_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    proxy_id_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.proxy_id)
  }
  
  // int64 query_id = 8;
  inline void QueryReqMsg::clear_query_id() {
    query_id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 QueryReqMsg::query_id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.query_id)
    return query_id_;
  }
  inline void QueryReqMsg::set_query_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    query_id_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.query_id)
  }
  
  // .milvus.grpc.ReqType req_type = 9;
  inline void QueryReqMsg::clear_req_type() {
    req_type_ = 0;
  }
  inline ::milvus::grpc::ReqType QueryReqMsg::req_type() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.QueryReqMsg.req_type)
    return static_cast< ::milvus::grpc::ReqType >(req_type_);
  }
  inline void QueryReqMsg::set_req_type(::milvus::grpc::ReqType value) {
    
    req_type_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.QueryReqMsg.req_type)
  }
  
  // -------------------------------------------------------------------
  
  // ManipulationReqMsg
  
  // string collection_name = 1;
  inline void ManipulationReqMsg::clear_collection_name() {
    collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& ManipulationReqMsg::collection_name() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.collection_name)
    return collection_name_.GetNoArena();
  }
  inline void ManipulationReqMsg::set_collection_name(const std::string& value) {
    
    collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.collection_name)
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.collection_name)
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.collection_name)
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.collection_name)
  }
  inline std::string* ManipulationReqMsg::mutable_collection_name() {
    
    // @@protoc_insertion_point(field_mutable:milvus.grpc.ManipulationReqMsg.collection_name)
    return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* ManipulationReqMsg::release_collection_name() {
    // @@protoc_insertion_point(field_release:milvus.grpc.ManipulationReqMsg.collection_name)
    
    return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.collection_name)
  }
  
  // string partition_tag = 2;
  inline void ManipulationReqMsg::clear_partition_tag() {
    partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& ManipulationReqMsg::partition_tag() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.partition_tag)
    return partition_tag_.GetNoArena();
  }
  inline void ManipulationReqMsg::set_partition_tag(const std::string& value) {
    
    partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.partition_tag)
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.partition_tag)
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.partition_tag)
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.partition_tag)
  }
  inline std::string* ManipulationReqMsg::mutable_partition_tag() {
    
    // @@protoc_insertion_point(field_mutable:milvus.grpc.ManipulationReqMsg.partition_tag)
    return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* ManipulationReqMsg::release_partition_tag() {
    // @@protoc_insertion_point(field_release:milvus.grpc.ManipulationReqMsg.partition_tag)
    
    return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void ManipulationReqMsg::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.ManipulationReqMsg.partition_tag)
  }
  
  // repeated int64 primary_keys = 3;
  inline int ManipulationReqMsg::primary_keys_size() const {
    return primary_keys_.size();
  }
  inline void ManipulationReqMsg::clear_primary_keys() {
    primary_keys_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 ManipulationReqMsg::primary_keys(int index) const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.primary_keys)
    return primary_keys_.Get(index);
  }
  inline void ManipulationReqMsg::set_primary_keys(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
    primary_keys_.Set(index, value);
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.primary_keys)
  }
  inline void ManipulationReqMsg::add_primary_keys(::PROTOBUF_NAMESPACE_ID::int64 value) {
    primary_keys_.Add(value);
    // @@protoc_insertion_point(field_add:milvus.grpc.ManipulationReqMsg.primary_keys)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  ManipulationReqMsg::primary_keys() const {
    // @@protoc_insertion_point(field_list:milvus.grpc.ManipulationReqMsg.primary_keys)
    return primary_keys_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  ManipulationReqMsg::mutable_primary_keys() {
    // @@protoc_insertion_point(field_mutable_list:milvus.grpc.ManipulationReqMsg.primary_keys)
    return &primary_keys_;
  }
  
  // repeated .milvus.grpc.RowData rows_data = 4;
  inline int ManipulationReqMsg::rows_data_size() const {
    return rows_data_.size();
  }
  inline void ManipulationReqMsg::clear_rows_data() {
    rows_data_.Clear();
  }
  inline ::milvus::grpc::RowData* ManipulationReqMsg::mutable_rows_data(int index) {
    // @@protoc_insertion_point(field_mutable:milvus.grpc.ManipulationReqMsg.rows_data)
    return rows_data_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >*
  ManipulationReqMsg::mutable_rows_data() {
    // @@protoc_insertion_point(field_mutable_list:milvus.grpc.ManipulationReqMsg.rows_data)
    return &rows_data_;
  }
  inline const ::milvus::grpc::RowData& ManipulationReqMsg::rows_data(int index) const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.rows_data)
    return rows_data_.Get(index);
  }
  inline ::milvus::grpc::RowData* ManipulationReqMsg::add_rows_data() {
    // @@protoc_insertion_point(field_add:milvus.grpc.ManipulationReqMsg.rows_data)
    return rows_data_.Add();
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >&
  ManipulationReqMsg::rows_data() const {
    // @@protoc_insertion_point(field_list:milvus.grpc.ManipulationReqMsg.rows_data)
    return rows_data_;
  }
  
  // uint64 timestamp = 5;
  inline void ManipulationReqMsg::clear_timestamp() {
    timestamp_ = PROTOBUF_ULONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 ManipulationReqMsg::timestamp() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.timestamp)
    return timestamp_;
  }
  inline void ManipulationReqMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    timestamp_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.timestamp)
  }
  
  // int64 segment_id = 6;
  inline void ManipulationReqMsg::clear_segment_id() {
    segment_id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 ManipulationReqMsg::segment_id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.segment_id)
    return segment_id_;
  }
  inline void ManipulationReqMsg::set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    segment_id_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.segment_id)
  }
  
  // int64 channel_id = 7;
  inline void ManipulationReqMsg::clear_channel_id() {
    channel_id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 ManipulationReqMsg::channel_id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.channel_id)
    return channel_id_;
  }
  inline void ManipulationReqMsg::set_channel_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    channel_id_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.channel_id)
  }
  
  // .milvus.grpc.ReqType req_type = 8;
  inline void ManipulationReqMsg::clear_req_type() {
    req_type_ = 0;
  }
  inline ::milvus::grpc::ReqType ManipulationReqMsg::req_type() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.req_type)
    return static_cast< ::milvus::grpc::ReqType >(req_type_);
  }
  inline void ManipulationReqMsg::set_req_type(::milvus::grpc::ReqType value) {
    
    req_type_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.req_type)
  }
  
  // int64 proxy_id = 9;
  inline void ManipulationReqMsg::clear_proxy_id() {
    proxy_id_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 ManipulationReqMsg::proxy_id() const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.proxy_id)
    return proxy_id_;
  }
  inline void ManipulationReqMsg::set_proxy_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    proxy_id_ = value;
    // @@protoc_insertion_point(field_set:milvus.grpc.ManipulationReqMsg.proxy_id)
  }
  
  // repeated .milvus.grpc.KeyValuePair extra_params = 10;
  inline int ManipulationReqMsg::extra_params_size() const {
    return extra_params_.size();
  }
  inline void ManipulationReqMsg::clear_extra_params() {
    extra_params_.Clear();
  }
  inline ::milvus::grpc::KeyValuePair* ManipulationReqMsg::mutable_extra_params(int index) {
    // @@protoc_insertion_point(field_mutable:milvus.grpc.ManipulationReqMsg.extra_params)
    return extra_params_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >*
  ManipulationReqMsg::mutable_extra_params() {
    // @@protoc_insertion_point(field_mutable_list:milvus.grpc.ManipulationReqMsg.extra_params)
    return &extra_params_;
  }
  inline const ::milvus::grpc::KeyValuePair& ManipulationReqMsg::extra_params(int index) const {
    // @@protoc_insertion_point(field_get:milvus.grpc.ManipulationReqMsg.extra_params)
    return extra_params_.Get(index);
  }
  inline ::milvus::grpc::KeyValuePair* ManipulationReqMsg::add_extra_params() {
    // @@protoc_insertion_point(field_add:milvus.grpc.ManipulationReqMsg.extra_params)
    return extra_params_.Add();
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
  ManipulationReqMsg::extra_params() const {
    // @@protoc_insertion_point(field_list:milvus.grpc.ManipulationReqMsg.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::ReqType> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::ReqType>() {
    return ::milvus::grpc::ReqType_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
  