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

#ifndef GOOGLE_PROTOBUF_INCLUDED_milvus_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_milvus_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3008000
#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 3008000 < 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/unknown_field_set.h>
#include "status.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_milvus_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_milvus_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[15]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto;
namespace milvus {
namespace grpc {
class BoolReply;
class BoolReplyDefaultTypeInternal;
extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_;
class Command;
class CommandDefaultTypeInternal;
extern CommandDefaultTypeInternal _Command_default_instance_;
class InsertInfos;
class InsertInfosDefaultTypeInternal;
extern InsertInfosDefaultTypeInternal _InsertInfos_default_instance_;
class QueryResult;
class QueryResultDefaultTypeInternal;
extern QueryResultDefaultTypeInternal _QueryResult_default_instance_;
class Range;
class RangeDefaultTypeInternal;
extern RangeDefaultTypeInternal _Range_default_instance_;
class RowRecord;
class RowRecordDefaultTypeInternal;
extern RowRecordDefaultTypeInternal _RowRecord_default_instance_;
class SearchVectorInFilesInfos;
class SearchVectorInFilesInfosDefaultTypeInternal;
extern SearchVectorInFilesInfosDefaultTypeInternal _SearchVectorInFilesInfos_default_instance_;
class SearchVectorInfos;
class SearchVectorInfosDefaultTypeInternal;
extern SearchVectorInfosDefaultTypeInternal _SearchVectorInfos_default_instance_;
class ServerStatus;
class ServerStatusDefaultTypeInternal;
extern ServerStatusDefaultTypeInternal _ServerStatus_default_instance_;
class StringReply;
class StringReplyDefaultTypeInternal;
extern StringReplyDefaultTypeInternal _StringReply_default_instance_;
class TableName;
class TableNameDefaultTypeInternal;
extern TableNameDefaultTypeInternal _TableName_default_instance_;
class TableRowCount;
class TableRowCountDefaultTypeInternal;
extern TableRowCountDefaultTypeInternal _TableRowCount_default_instance_;
class TableSchema;
class TableSchemaDefaultTypeInternal;
extern TableSchemaDefaultTypeInternal _TableSchema_default_instance_;
class TopKQueryResult;
class TopKQueryResultDefaultTypeInternal;
extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_;
class VectorIds;
class VectorIdsDefaultTypeInternal;
extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_;
}  // namespace grpc
}  // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*);
template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*);
template<> ::milvus::grpc::InsertInfos* Arena::CreateMaybeMessage<::milvus::grpc::InsertInfos>(Arena*);
template<> ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage<::milvus::grpc::QueryResult>(Arena*);
template<> ::milvus::grpc::Range* Arena::CreateMaybeMessage<::milvus::grpc::Range>(Arena*);
template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*);
template<> ::milvus::grpc::SearchVectorInFilesInfos* Arena::CreateMaybeMessage<::milvus::grpc::SearchVectorInFilesInfos>(Arena*);
template<> ::milvus::grpc::SearchVectorInfos* Arena::CreateMaybeMessage<::milvus::grpc::SearchVectorInfos>(Arena*);
template<> ::milvus::grpc::ServerStatus* Arena::CreateMaybeMessage<::milvus::grpc::ServerStatus>(Arena*);
template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*);
template<> ::milvus::grpc::TableName* Arena::CreateMaybeMessage<::milvus::grpc::TableName>(Arena*);
template<> ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage<::milvus::grpc::TableRowCount>(Arena*);
template<> ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage<::milvus::grpc::TableSchema>(Arena*);
template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*);
template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
namespace grpc {

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

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

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

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

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

  void Swap(TableName* other);
  friend void swap(TableName& a, TableName& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // string table_name = 2;
  void clear_table_name();
  static const int kTableNameFieldNumber = 2;
  const std::string& table_name() const;
  void set_table_name(const std::string& value);
  void set_table_name(std::string&& value);
  void set_table_name(const char* value);
  void set_table_name(const char* value, size_t size);
  std::string* mutable_table_name();
  std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);

  // .milvus.grpc.Status status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  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.TableName)
 private:
  class HasBitSetters;

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

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

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

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

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

  void Swap(TableSchema* other);
  friend void swap(TableSchema& a, TableSchema& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // .milvus.grpc.TableName table_name = 1;
  bool has_table_name() const;
  void clear_table_name();
  static const int kTableNameFieldNumber = 1;
  const ::milvus::grpc::TableName& table_name() const;
  ::milvus::grpc::TableName* release_table_name();
  ::milvus::grpc::TableName* mutable_table_name();
  void set_allocated_table_name(::milvus::grpc::TableName* table_name);

  // int64 dimension = 3;
  void clear_dimension();
  static const int kDimensionFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::int64 dimension() const;
  void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int32 index_type = 2;
  void clear_index_type();
  static const int kIndexTypeFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::int32 index_type() const;
  void set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value);

  // bool store_raw_vector = 4;
  void clear_store_raw_vector();
  static const int kStoreRawVectorFieldNumber = 4;
  bool store_raw_vector() const;
  void set_store_raw_vector(bool value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.TableSchema)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::grpc::TableName* table_name_;
  ::PROTOBUF_NAMESPACE_ID::int64 dimension_;
  ::PROTOBUF_NAMESPACE_ID::int32 index_type_;
  bool store_raw_vector_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(Range* other);
  friend void swap(Range& a, Range& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // string start_value = 1;
  void clear_start_value();
  static const int kStartValueFieldNumber = 1;
  const std::string& start_value() const;
  void set_start_value(const std::string& value);
  void set_start_value(std::string&& value);
  void set_start_value(const char* value);
  void set_start_value(const char* value, size_t size);
  std::string* mutable_start_value();
  std::string* release_start_value();
  void set_allocated_start_value(std::string* start_value);

  // string end_value = 2;
  void clear_end_value();
  static const int kEndValueFieldNumber = 2;
  const std::string& end_value() const;
  void set_end_value(const std::string& value);
  void set_end_value(std::string&& value);
  void set_end_value(const char* value);
  void set_end_value(const char* value, size_t size);
  std::string* mutable_end_value();
  std::string* release_end_value();
  void set_allocated_end_value(std::string* end_value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.Range)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr start_value_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr end_value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(RowRecord* other);
  friend void swap(RowRecord& a, RowRecord& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // repeated float vector_data = 1;
  int vector_data_size() const;
  void clear_vector_data();
  static const int kVectorDataFieldNumber = 1;
  float vector_data(int index) const;
  void set_vector_data(int index, float value);
  void add_vector_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      vector_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_vector_data();

  // @@protoc_insertion_point(class_scope:milvus.grpc.RowRecord)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > vector_data_;
  mutable std::atomic<int> _vector_data_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(InsertInfos* other);
  friend void swap(InsertInfos& a, InsertInfos& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // repeated .milvus.grpc.RowRecord row_record_array = 2;
  int row_record_array_size() const;
  void clear_row_record_array();
  static const int kRowRecordArrayFieldNumber = 2;
  ::milvus::grpc::RowRecord* mutable_row_record_array(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
      mutable_row_record_array();
  const ::milvus::grpc::RowRecord& row_record_array(int index) const;
  ::milvus::grpc::RowRecord* add_row_record_array();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
      row_record_array() const;

  // string table_name = 1;
  void clear_table_name();
  static const int kTableNameFieldNumber = 1;
  const std::string& table_name() const;
  void set_table_name(const std::string& value);
  void set_table_name(std::string&& value);
  void set_table_name(const char* value);
  void set_table_name(const char* value, size_t size);
  std::string* mutable_table_name();
  std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);

  // @@protoc_insertion_point(class_scope:milvus.grpc.InsertInfos)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > row_record_array_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(VectorIds* other);
  friend void swap(VectorIds& a, VectorIds& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // repeated int64 vector_id_array = 2;
  int vector_id_array_size() const;
  void clear_vector_id_array();
  static const int kVectorIdArrayFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::int64 vector_id_array(int index) const;
  void set_vector_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_vector_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      vector_id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_vector_id_array();

  // .milvus.grpc.Status status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  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.VectorIds)
 private:
  class HasBitSetters;

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

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

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

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

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

  void Swap(SearchVectorInfos* other);
  friend void swap(SearchVectorInfos& a, SearchVectorInfos& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // repeated .milvus.grpc.RowRecord query_record_array = 2;
  int query_record_array_size() const;
  void clear_query_record_array();
  static const int kQueryRecordArrayFieldNumber = 2;
  ::milvus::grpc::RowRecord* mutable_query_record_array(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
      mutable_query_record_array();
  const ::milvus::grpc::RowRecord& query_record_array(int index) const;
  ::milvus::grpc::RowRecord* add_query_record_array();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
      query_record_array() const;

  // repeated .milvus.grpc.Range query_range_array = 3;
  int query_range_array_size() const;
  void clear_query_range_array();
  static const int kQueryRangeArrayFieldNumber = 3;
  ::milvus::grpc::Range* mutable_query_range_array(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >*
      mutable_query_range_array();
  const ::milvus::grpc::Range& query_range_array(int index) const;
  ::milvus::grpc::Range* add_query_range_array();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >&
      query_range_array() const;

  // string table_name = 1;
  void clear_table_name();
  static const int kTableNameFieldNumber = 1;
  const std::string& table_name() const;
  void set_table_name(const std::string& value);
  void set_table_name(std::string&& value);
  void set_table_name(const char* value);
  void set_table_name(const char* value, size_t size);
  std::string* mutable_table_name();
  std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);

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

  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchVectorInfos)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > query_record_array_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range > query_range_array_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
  ::PROTOBUF_NAMESPACE_ID::int64 topk_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(SearchVectorInFilesInfos* other);
  friend void swap(SearchVectorInFilesInfos& a, SearchVectorInFilesInfos& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // repeated string file_id_array = 1;
  int file_id_array_size() const;
  void clear_file_id_array();
  static const int kFileIdArrayFieldNumber = 1;
  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.SearchVectorInfos search_vector_infos = 2;
  bool has_search_vector_infos() const;
  void clear_search_vector_infos();
  static const int kSearchVectorInfosFieldNumber = 2;
  const ::milvus::grpc::SearchVectorInfos& search_vector_infos() const;
  ::milvus::grpc::SearchVectorInfos* release_search_vector_infos();
  ::milvus::grpc::SearchVectorInfos* mutable_search_vector_infos();
  void set_allocated_search_vector_infos(::milvus::grpc::SearchVectorInfos* search_vector_infos);

  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchVectorInFilesInfos)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_id_array_;
  ::milvus::grpc::SearchVectorInfos* search_vector_infos_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_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 =
    8;

  void Swap(QueryResult* other);
  friend void swap(QueryResult& a, QueryResult& b) {
    a.Swap(&b);
  }

  // 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_milvus_2eproto);
    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // int64 id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::int64 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // double distance = 2;
  void clear_distance();
  static const int kDistanceFieldNumber = 2;
  double distance() const;
  void set_distance(double value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int64 id_;
  double distance_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(TopKQueryResult* other);
  friend void swap(TopKQueryResult& a, TopKQueryResult& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // repeated .milvus.grpc.QueryResult query_result_arrays = 2;
  int query_result_arrays_size() const;
  void clear_query_result_arrays();
  static const int kQueryResultArraysFieldNumber = 2;
  ::milvus::grpc::QueryResult* mutable_query_result_arrays(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >*
      mutable_query_result_arrays();
  const ::milvus::grpc::QueryResult& query_result_arrays(int index) const;
  ::milvus::grpc::QueryResult* add_query_result_arrays();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >&
      query_result_arrays() const;

  // .milvus.grpc.Status status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  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.TopKQueryResult)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult > query_result_arrays_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_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 =
    10;

  void Swap(StringReply* other);
  friend void swap(StringReply& a, StringReply& b) {
    a.Swap(&b);
  }

  // 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_milvus_2eproto);
    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string string_reply = 2;
  void clear_string_reply();
  static const int kStringReplyFieldNumber = 2;
  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();
  static const int kStatusFieldNumber = 1;
  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 HasBitSetters;

  ::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_milvus_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 =
    11;

  void Swap(BoolReply* other);
  friend void swap(BoolReply& a, BoolReply& b) {
    a.Swap(&b);
  }

  // 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_milvus_2eproto);
    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // .milvus.grpc.Status status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  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();
  static const int kBoolReplyFieldNumber = 2;
  bool bool_reply() const;
  void set_bool_reply(bool value);

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

  ::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_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  void Swap(TableRowCount* other);
  friend void swap(TableRowCount& a, TableRowCount& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // .milvus.grpc.Status status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  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 table_row_count = 2;
  void clear_table_row_count();
  static const int kTableRowCountFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::int64 table_row_count() const;
  void set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:milvus.grpc.TableRowCount)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::grpc::Status* status_;
  ::PROTOBUF_NAMESPACE_ID::int64 table_row_count_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_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 =
    13;

  void Swap(Command* other);
  friend void swap(Command& a, Command& b) {
    a.Swap(&b);
  }

  // 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_milvus_2eproto);
    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string cmd = 1;
  void clear_cmd();
  static const int kCmdFieldNumber = 1;
  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 HasBitSetters;

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

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

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

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

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

  void Swap(ServerStatus* other);
  friend void swap(ServerStatus& a, ServerStatus& b) {
    a.Swap(&b);
  }

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

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

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

  public:

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

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

  // string info = 2;
  void clear_info();
  static const int kInfoFieldNumber = 2;
  const std::string& info() const;
  void set_info(const std::string& value);
  void set_info(std::string&& value);
  void set_info(const char* value);
  void set_info(const char* value, size_t size);
  std::string* mutable_info();
  std::string* release_info();
  void set_allocated_info(std::string* info);

  // .milvus.grpc.Status status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  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.ServerStatus)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr info_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// ===================================================================


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

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

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

// string table_name = 2;
inline void TableName::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TableName::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableName.table_name)
  return table_name_.GetNoArena();
}
inline void TableName::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.TableName.table_name)
}
inline void TableName::set_table_name(std::string&& value) {
  
  table_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableName.table_name)
}
inline void TableName::set_table_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.TableName.table_name)
}
inline void TableName::set_table_name(const char* value, size_t size) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableName.table_name)
}
inline std::string* TableName::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableName.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TableName::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.TableName.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TableName::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableName.table_name)
}

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

// TableSchema

// .milvus.grpc.TableName table_name = 1;
inline bool TableSchema::has_table_name() const {
  return this != internal_default_instance() && table_name_ != nullptr;
}
inline void TableSchema::clear_table_name() {
  if (GetArenaNoVirtual() == nullptr && table_name_ != nullptr) {
    delete table_name_;
  }
  table_name_ = nullptr;
}
inline const ::milvus::grpc::TableName& TableSchema::table_name() const {
  const ::milvus::grpc::TableName* p = table_name_;
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::TableName*>(
      &::milvus::grpc::_TableName_default_instance_);
}
inline ::milvus::grpc::TableName* TableSchema::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name)
  
  ::milvus::grpc::TableName* temp = table_name_;
  table_name_ = nullptr;
  return temp;
}
inline ::milvus::grpc::TableName* TableSchema::mutable_table_name() {
  
  if (table_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::TableName>(GetArenaNoVirtual());
    table_name_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name)
  return table_name_;
}
inline void TableSchema::set_allocated_table_name(::milvus::grpc::TableName* table_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete table_name_;
  }
  if (table_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      table_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, table_name, submessage_arena);
    }
    
  } else {
    
  }
  table_name_ = table_name;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.table_name)
}

// int32 index_type = 2;
inline void TableSchema::clear_index_type() {
  index_type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TableSchema::index_type() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.index_type)
  return index_type_;
}
inline void TableSchema::set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  index_type_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.index_type)
}

// int64 dimension = 3;
inline void TableSchema::clear_dimension() {
  dimension_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::dimension() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.dimension)
  return dimension_;
}
inline void TableSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  dimension_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.dimension)
}

// bool store_raw_vector = 4;
inline void TableSchema::clear_store_raw_vector() {
  store_raw_vector_ = false;
}
inline bool TableSchema::store_raw_vector() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.store_raw_vector)
  return store_raw_vector_;
}
inline void TableSchema::set_store_raw_vector(bool value) {
  
  store_raw_vector_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.store_raw_vector)
}

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

// Range

// string start_value = 1;
inline void Range::clear_start_value() {
  start_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Range::start_value() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Range.start_value)
  return start_value_.GetNoArena();
}
inline void Range::set_start_value(const std::string& value) {
  
  start_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Range.start_value)
}
inline void Range::set_start_value(std::string&& value) {
  
  start_value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Range.start_value)
}
inline void Range::set_start_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  start_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.Range.start_value)
}
inline void Range::set_start_value(const char* value, size_t size) {
  
  start_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Range.start_value)
}
inline std::string* Range::mutable_start_value() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Range.start_value)
  return start_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Range::release_start_value() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Range.start_value)
  
  return start_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Range::set_allocated_start_value(std::string* start_value) {
  if (start_value != nullptr) {
    
  } else {
    
  }
  start_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), start_value);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Range.start_value)
}

// string end_value = 2;
inline void Range::clear_end_value() {
  end_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Range::end_value() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Range.end_value)
  return end_value_.GetNoArena();
}
inline void Range::set_end_value(const std::string& value) {
  
  end_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.Range.end_value)
}
inline void Range::set_end_value(std::string&& value) {
  
  end_value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Range.end_value)
}
inline void Range::set_end_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  end_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.Range.end_value)
}
inline void Range::set_end_value(const char* value, size_t size) {
  
  end_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Range.end_value)
}
inline std::string* Range::mutable_end_value() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.Range.end_value)
  return end_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Range::release_end_value() {
  // @@protoc_insertion_point(field_release:milvus.grpc.Range.end_value)
  
  return end_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Range::set_allocated_end_value(std::string* end_value) {
  if (end_value != nullptr) {
    
  } else {
    
  }
  end_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), end_value);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Range.end_value)
}

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

// RowRecord

// repeated float vector_data = 1;
inline int RowRecord::vector_data_size() const {
  return vector_data_.size();
}
inline void RowRecord::clear_vector_data() {
  vector_data_.Clear();
}
inline float RowRecord::vector_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.RowRecord.vector_data)
  return vector_data_.Get(index);
}
inline void RowRecord::set_vector_data(int index, float value) {
  vector_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.RowRecord.vector_data)
}
inline void RowRecord::add_vector_data(float value) {
  vector_data_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.RowRecord.vector_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
RowRecord::vector_data() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.RowRecord.vector_data)
  return vector_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
RowRecord::mutable_vector_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RowRecord.vector_data)
  return &vector_data_;
}

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

// InsertInfos

// string table_name = 1;
inline void InsertInfos::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& InsertInfos::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertInfos.table_name)
  return table_name_.GetNoArena();
}
inline void InsertInfos::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertInfos.table_name)
}
inline void InsertInfos::set_table_name(std::string&& value) {
  
  table_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertInfos.table_name)
}
inline void InsertInfos::set_table_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertInfos.table_name)
}
inline void InsertInfos::set_table_name(const char* value, size_t size) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertInfos.table_name)
}
inline std::string* InsertInfos::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertInfos.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* InsertInfos::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertInfos.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void InsertInfos::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertInfos.table_name)
}

// repeated .milvus.grpc.RowRecord row_record_array = 2;
inline int InsertInfos::row_record_array_size() const {
  return row_record_array_.size();
}
inline void InsertInfos::clear_row_record_array() {
  row_record_array_.Clear();
}
inline ::milvus::grpc::RowRecord* InsertInfos::mutable_row_record_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertInfos.row_record_array)
  return row_record_array_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
InsertInfos::mutable_row_record_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertInfos.row_record_array)
  return &row_record_array_;
}
inline const ::milvus::grpc::RowRecord& InsertInfos::row_record_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertInfos.row_record_array)
  return row_record_array_.Get(index);
}
inline ::milvus::grpc::RowRecord* InsertInfos::add_row_record_array() {
  // @@protoc_insertion_point(field_add:milvus.grpc.InsertInfos.row_record_array)
  return row_record_array_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
InsertInfos::row_record_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.InsertInfos.row_record_array)
  return row_record_array_;
}

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

// VectorIds

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

// repeated int64 vector_id_array = 2;
inline int VectorIds::vector_id_array_size() const {
  return vector_id_array_.size();
}
inline void VectorIds::clear_vector_id_array() {
  vector_id_array_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 VectorIds::vector_id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.VectorIds.vector_id_array)
  return vector_id_array_.Get(index);
}
inline void VectorIds::set_vector_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  vector_id_array_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.VectorIds.vector_id_array)
}
inline void VectorIds::add_vector_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
  vector_id_array_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.VectorIds.vector_id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
VectorIds::vector_id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.VectorIds.vector_id_array)
  return vector_id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
VectorIds::mutable_vector_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorIds.vector_id_array)
  return &vector_id_array_;
}

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

// SearchVectorInfos

// string table_name = 1;
inline void SearchVectorInfos::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchVectorInfos::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchVectorInfos.table_name)
  return table_name_.GetNoArena();
}
inline void SearchVectorInfos::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchVectorInfos.table_name)
}
inline void SearchVectorInfos::set_table_name(std::string&& value) {
  
  table_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchVectorInfos.table_name)
}
inline void SearchVectorInfos::set_table_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchVectorInfos.table_name)
}
inline void SearchVectorInfos::set_table_name(const char* value, size_t size) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchVectorInfos.table_name)
}
inline std::string* SearchVectorInfos::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchVectorInfos.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchVectorInfos::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchVectorInfos.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchVectorInfos::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchVectorInfos.table_name)
}

// repeated .milvus.grpc.RowRecord query_record_array = 2;
inline int SearchVectorInfos::query_record_array_size() const {
  return query_record_array_.size();
}
inline void SearchVectorInfos::clear_query_record_array() {
  query_record_array_.Clear();
}
inline ::milvus::grpc::RowRecord* SearchVectorInfos::mutable_query_record_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchVectorInfos.query_record_array)
  return query_record_array_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
SearchVectorInfos::mutable_query_record_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchVectorInfos.query_record_array)
  return &query_record_array_;
}
inline const ::milvus::grpc::RowRecord& SearchVectorInfos::query_record_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchVectorInfos.query_record_array)
  return query_record_array_.Get(index);
}
inline ::milvus::grpc::RowRecord* SearchVectorInfos::add_query_record_array() {
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchVectorInfos.query_record_array)
  return query_record_array_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
SearchVectorInfos::query_record_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchVectorInfos.query_record_array)
  return query_record_array_;
}

// repeated .milvus.grpc.Range query_range_array = 3;
inline int SearchVectorInfos::query_range_array_size() const {
  return query_range_array_.size();
}
inline void SearchVectorInfos::clear_query_range_array() {
  query_range_array_.Clear();
}
inline ::milvus::grpc::Range* SearchVectorInfos::mutable_query_range_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchVectorInfos.query_range_array)
  return query_range_array_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >*
SearchVectorInfos::mutable_query_range_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchVectorInfos.query_range_array)
  return &query_range_array_;
}
inline const ::milvus::grpc::Range& SearchVectorInfos::query_range_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchVectorInfos.query_range_array)
  return query_range_array_.Get(index);
}
inline ::milvus::grpc::Range* SearchVectorInfos::add_query_range_array() {
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchVectorInfos.query_range_array)
  return query_range_array_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >&
SearchVectorInfos::query_range_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchVectorInfos.query_range_array)
  return query_range_array_;
}

// int64 topk = 4;
inline void SearchVectorInfos::clear_topk() {
  topk_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SearchVectorInfos::topk() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchVectorInfos.topk)
  return topk_;
}
inline void SearchVectorInfos::set_topk(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  topk_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchVectorInfos.topk)
}

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

// SearchVectorInFilesInfos

// repeated string file_id_array = 1;
inline int SearchVectorInFilesInfos::file_id_array_size() const {
  return file_id_array_.size();
}
inline void SearchVectorInFilesInfos::clear_file_id_array() {
  file_id_array_.Clear();
}
inline const std::string& SearchVectorInFilesInfos::file_id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  return file_id_array_.Get(index);
}
inline std::string* SearchVectorInFilesInfos::mutable_file_id_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  return file_id_array_.Mutable(index);
}
inline void SearchVectorInFilesInfos::set_file_id_array(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  file_id_array_.Mutable(index)->assign(value);
}
inline void SearchVectorInFilesInfos::set_file_id_array(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  file_id_array_.Mutable(index)->assign(std::move(value));
}
inline void SearchVectorInFilesInfos::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.SearchVectorInFilesInfos.file_id_array)
}
inline void SearchVectorInFilesInfos::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.SearchVectorInFilesInfos.file_id_array)
}
inline std::string* SearchVectorInFilesInfos::add_file_id_array() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  return file_id_array_.Add();
}
inline void SearchVectorInFilesInfos::add_file_id_array(const std::string& value) {
  file_id_array_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
}
inline void SearchVectorInFilesInfos::add_file_id_array(std::string&& value) {
  file_id_array_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
}
inline void SearchVectorInFilesInfos::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.SearchVectorInFilesInfos.file_id_array)
}
inline void SearchVectorInFilesInfos::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.SearchVectorInFilesInfos.file_id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchVectorInFilesInfos::file_id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  return file_id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchVectorInFilesInfos::mutable_file_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchVectorInFilesInfos.file_id_array)
  return &file_id_array_;
}

// .milvus.grpc.SearchVectorInfos search_vector_infos = 2;
inline bool SearchVectorInFilesInfos::has_search_vector_infos() const {
  return this != internal_default_instance() && search_vector_infos_ != nullptr;
}
inline void SearchVectorInFilesInfos::clear_search_vector_infos() {
  if (GetArenaNoVirtual() == nullptr && search_vector_infos_ != nullptr) {
    delete search_vector_infos_;
  }
  search_vector_infos_ = nullptr;
}
inline const ::milvus::grpc::SearchVectorInfos& SearchVectorInFilesInfos::search_vector_infos() const {
  const ::milvus::grpc::SearchVectorInfos* p = search_vector_infos_;
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchVectorInFilesInfos.search_vector_infos)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::SearchVectorInfos*>(
      &::milvus::grpc::_SearchVectorInfos_default_instance_);
}
inline ::milvus::grpc::SearchVectorInfos* SearchVectorInFilesInfos::release_search_vector_infos() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchVectorInFilesInfos.search_vector_infos)
  
  ::milvus::grpc::SearchVectorInfos* temp = search_vector_infos_;
  search_vector_infos_ = nullptr;
  return temp;
}
inline ::milvus::grpc::SearchVectorInfos* SearchVectorInFilesInfos::mutable_search_vector_infos() {
  
  if (search_vector_infos_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::SearchVectorInfos>(GetArenaNoVirtual());
    search_vector_infos_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchVectorInFilesInfos.search_vector_infos)
  return search_vector_infos_;
}
inline void SearchVectorInFilesInfos::set_allocated_search_vector_infos(::milvus::grpc::SearchVectorInfos* search_vector_infos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete search_vector_infos_;
  }
  if (search_vector_infos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      search_vector_infos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, search_vector_infos, submessage_arena);
    }
    
  } else {
    
  }
  search_vector_infos_ = search_vector_infos;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchVectorInFilesInfos.search_vector_infos)
}

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

// QueryResult

// int64 id = 1;
inline void QueryResult::clear_id() {
  id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::id() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.id)
  return id_;
}
inline void QueryResult::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.id)
}

// double distance = 2;
inline void QueryResult::clear_distance() {
  distance_ = 0;
}
inline double QueryResult::distance() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.distance)
  return distance_;
}
inline void QueryResult::set_distance(double value) {
  
  distance_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.distance)
}

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

// TopKQueryResult

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

// repeated .milvus.grpc.QueryResult query_result_arrays = 2;
inline int TopKQueryResult::query_result_arrays_size() const {
  return query_result_arrays_.size();
}
inline void TopKQueryResult::clear_query_result_arrays() {
  query_result_arrays_.Clear();
}
inline ::milvus::grpc::QueryResult* TopKQueryResult::mutable_query_result_arrays(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResult.query_result_arrays)
  return query_result_arrays_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >*
TopKQueryResult::mutable_query_result_arrays() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResult.query_result_arrays)
  return &query_result_arrays_;
}
inline const ::milvus::grpc::QueryResult& TopKQueryResult::query_result_arrays(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.query_result_arrays)
  return query_result_arrays_.Get(index);
}
inline ::milvus::grpc::QueryResult* TopKQueryResult::add_query_result_arrays() {
  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResult.query_result_arrays)
  return query_result_arrays_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >&
TopKQueryResult::query_result_arrays() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResult.query_result_arrays)
  return query_result_arrays_;
}

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

// StringReply

// .milvus.grpc.Status status = 1;
inline bool StringReply::has_status() const {
  return this != internal_default_instance() && 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 reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.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 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 reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.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)
}

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

// TableRowCount

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

// int64 table_row_count = 2;
inline void TableRowCount::clear_table_row_count() {
  table_row_count_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TableRowCount::table_row_count() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.table_row_count)
  return table_row_count_;
}
inline void TableRowCount::set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  table_row_count_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TableRowCount.table_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)
}

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

// ServerStatus

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

// string info = 2;
inline void ServerStatus::clear_info() {
  info_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ServerStatus::info() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.ServerStatus.info)
  return info_.GetNoArena();
}
inline void ServerStatus::set_info(const std::string& value) {
  
  info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.ServerStatus.info)
}
inline void ServerStatus::set_info(std::string&& value) {
  
  info_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.ServerStatus.info)
}
inline void ServerStatus::set_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.ServerStatus.info)
}
inline void ServerStatus::set_info(const char* value, size_t size) {
  
  info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.ServerStatus.info)
}
inline std::string* ServerStatus::mutable_info() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.ServerStatus.info)
  return info_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ServerStatus::release_info() {
  // @@protoc_insertion_point(field_release:milvus.grpc.ServerStatus.info)
  
  return info_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ServerStatus::set_allocated_info(std::string* info) {
  if (info != nullptr) {
    
  } else {
    
  }
  info_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), info);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.ServerStatus.info)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace grpc
}  // namespace milvus

// @@protoc_insertion_point(global_scope)

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