// 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 < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/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[20]
    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 DeleteByDateParam;
class DeleteByDateParamDefaultTypeInternal;
extern DeleteByDateParamDefaultTypeInternal _DeleteByDateParam_default_instance_;
class Index;
class IndexDefaultTypeInternal;
extern IndexDefaultTypeInternal _Index_default_instance_;
class IndexParam;
class IndexParamDefaultTypeInternal;
extern IndexParamDefaultTypeInternal _IndexParam_default_instance_;
class InsertParam;
class InsertParamDefaultTypeInternal;
extern InsertParamDefaultTypeInternal _InsertParam_default_instance_;
class PartitionList;
class PartitionListDefaultTypeInternal;
extern PartitionListDefaultTypeInternal _PartitionList_default_instance_;
class PartitionName;
class PartitionNameDefaultTypeInternal;
extern PartitionNameDefaultTypeInternal _PartitionName_default_instance_;
class PartitionParam;
class PartitionParamDefaultTypeInternal;
extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_;
class Range;
class RangeDefaultTypeInternal;
extern RangeDefaultTypeInternal _Range_default_instance_;
class RowRecord;
class RowRecordDefaultTypeInternal;
extern RowRecordDefaultTypeInternal _RowRecord_default_instance_;
class SearchInFilesParam;
class SearchInFilesParamDefaultTypeInternal;
extern SearchInFilesParamDefaultTypeInternal _SearchInFilesParam_default_instance_;
class SearchParam;
class SearchParamDefaultTypeInternal;
extern SearchParamDefaultTypeInternal _SearchParam_default_instance_;
class StringReply;
class StringReplyDefaultTypeInternal;
extern StringReplyDefaultTypeInternal _StringReply_default_instance_;
class TableName;
class TableNameDefaultTypeInternal;
extern TableNameDefaultTypeInternal _TableName_default_instance_;
class TableNameList;
class TableNameListDefaultTypeInternal;
extern TableNameListDefaultTypeInternal _TableNameList_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::DeleteByDateParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByDateParam>(Arena*);
template<> ::milvus::grpc::Index* Arena::CreateMaybeMessage<::milvus::grpc::Index>(Arena*);
template<> ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage<::milvus::grpc::IndexParam>(Arena*);
template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc::InsertParam>(Arena*);
template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*);
template<> ::milvus::grpc::PartitionName* Arena::CreateMaybeMessage<::milvus::grpc::PartitionName>(Arena*);
template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*);
template<> ::milvus::grpc::Range* Arena::CreateMaybeMessage<::milvus::grpc::Range>(Arena*);
template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*);
template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*);
template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*);
template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*);
template<> ::milvus::grpc::TableName* Arena::CreateMaybeMessage<::milvus::grpc::TableName>(Arena*);
template<> ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage<::milvus::grpc::TableNameList>(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;

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

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

  enum : int {
    kTableNameFieldNumber = 1,
  };
  // string table_name = 1;
  void clear_table_name();
  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.TableName)
 private:
  class _Internal;

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kPartitionNameFieldNumber = 1,
  };
  // string partition_name = 1;
  void clear_partition_name();
  const std::string& partition_name() const;
  void set_partition_name(const std::string& value);
  void set_partition_name(std::string&& value);
  void set_partition_name(const char* value);
  void set_partition_name(const char* value, size_t size);
  std::string* mutable_partition_name();
  std::string* release_partition_name();
  void set_allocated_partition_name(std::string* partition_name);

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kTableNamesFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated string table_names = 2;
  int table_names_size() const;
  void clear_table_names();
  const std::string& table_names(int index) const;
  std::string* mutable_table_names(int index);
  void set_table_names(int index, const std::string& value);
  void set_table_names(int index, std::string&& value);
  void set_table_names(int index, const char* value);
  void set_table_names(int index, const char* value, size_t size);
  std::string* add_table_names();
  void add_table_names(const std::string& value);
  void add_table_names(std::string&& value);
  void add_table_names(const char* value);
  void add_table_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& table_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_table_names();

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> table_names_;
  ::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 =
    3;

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

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

  enum : int {
    kTableNameFieldNumber = 2,
    kStatusFieldNumber = 1,
    kDimensionFieldNumber = 3,
    kIndexFileSizeFieldNumber = 4,
    kMetricTypeFieldNumber = 5,
  };
  // string table_name = 2;
  void clear_table_name();
  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();
  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 dimension = 3;
  void clear_dimension();
  ::PROTOBUF_NAMESPACE_ID::int64 dimension() const;
  void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 index_file_size = 4;
  void clear_index_file_size();
  ::PROTOBUF_NAMESPACE_ID::int64 index_file_size() const;
  void set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int32 metric_type = 5;
  void clear_metric_type();
  ::PROTOBUF_NAMESPACE_ID::int32 metric_type() const;
  void set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kTableNameFieldNumber = 1,
    kPartitionNameFieldNumber = 2,
    kTagFieldNumber = 3,
  };
  // string table_name = 1;
  void clear_table_name();
  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);

  // string partition_name = 2;
  void clear_partition_name();
  const std::string& partition_name() const;
  void set_partition_name(const std::string& value);
  void set_partition_name(std::string&& value);
  void set_partition_name(const char* value);
  void set_partition_name(const char* value, size_t size);
  std::string* mutable_partition_name();
  std::string* release_partition_name();
  void set_allocated_partition_name(std::string* partition_name);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kPartitionArrayFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated .milvus.grpc.PartitionParam partition_array = 2;
  int partition_array_size() const;
  void clear_partition_array();
  ::milvus::grpc::PartitionParam* mutable_partition_array(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionParam >*
      mutable_partition_array();
  const ::milvus::grpc::PartitionParam& partition_array(int index) const;
  ::milvus::grpc::PartitionParam* add_partition_array();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionParam >&
      partition_array() const;

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionParam > partition_array_;
  ::milvus::grpc::Status* status_;
  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 =
    6;

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

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

  enum : int {
    kStartValueFieldNumber = 1,
    kEndValueFieldNumber = 2,
  };
  // string start_value = 1;
  void clear_start_value();
  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();
  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 _Internal;

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

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

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

  enum : int {
    kVectorDataFieldNumber = 1,
  };
  // repeated float vector_data = 1;
  int vector_data_size() const;
  void clear_vector_data();
  float vector_data(int index) const;
  void set_vector_data(int index, float value);
//  void add_vector_data(float value);
  void add_vector_data(std::vector<float>::const_iterator begin, std::vector<float>::const_iterator end);
  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 _Internal;

  ::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 InsertParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.InsertParam) */ {
 public:
  InsertParam();
  virtual ~InsertParam();

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kRowRecordArrayFieldNumber = 2,
    kRowIdArrayFieldNumber = 3,
    kTableNameFieldNumber = 1,
    kPartitionTagFieldNumber = 4,
  };
  // repeated .milvus.grpc.RowRecord row_record_array = 2;
  int row_record_array_size() const;
  void clear_row_record_array();
  ::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;

  // repeated int64 row_id_array = 3;
  int row_id_array_size() const;
  void clear_row_id_array();
  ::PROTOBUF_NAMESPACE_ID::int64 row_id_array(int index) const;
  void set_row_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
//  void add_row_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_row_id_array(std::vector<::PROTOBUF_NAMESPACE_ID::int64>::const_iterator begin,
                        std::vector<::PROTOBUF_NAMESPACE_ID::int64>::const_iterator end);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      row_id_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_row_id_array();

  // string table_name = 1;
  void clear_table_name();
  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);

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > row_record_array_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > row_id_array_;
  mutable std::atomic<int> _row_id_array_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_;
  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 =
    9;

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

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

  enum : int {
    kVectorIdArrayFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated int64 vector_id_array = 2;
  int vector_id_array_size() const;
  void clear_vector_id_array();
  ::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();
  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 _Internal;

  ::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 SearchParam :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchParam) */ {
 public:
  SearchParam();
  virtual ~SearchParam();

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kQueryRecordArrayFieldNumber = 2,
    kQueryRangeArrayFieldNumber = 3,
    kPartitionTagArrayFieldNumber = 6,
    kTableNameFieldNumber = 1,
    kTopkFieldNumber = 4,
    kNprobeFieldNumber = 5,
  };
  // repeated .milvus.grpc.RowRecord query_record_array = 2;
  int query_record_array_size() const;
  void clear_query_record_array();
  ::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();
  ::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;

  // repeated string partition_tag_array = 6;
  int partition_tag_array_size() const;
  void clear_partition_tag_array();
  const std::string& partition_tag_array(int index) const;
  std::string* mutable_partition_tag_array(int index);
  void set_partition_tag_array(int index, const std::string& value);
  void set_partition_tag_array(int index, std::string&& value);
  void set_partition_tag_array(int index, const char* value);
  void set_partition_tag_array(int index, const char* value, size_t size);
  std::string* add_partition_tag_array();
  void add_partition_tag_array(const std::string& value);
  void add_partition_tag_array(std::string&& value);
  void add_partition_tag_array(const char* value);
  void add_partition_tag_array(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tag_array() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tag_array();

  // string table_name = 1;
  void clear_table_name();
  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();
  ::PROTOBUF_NAMESPACE_ID::int64 topk() const;
  void set_topk(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 nprobe = 5;
  void clear_nprobe();
  ::PROTOBUF_NAMESPACE_ID::int64 nprobe() const;
  void set_nprobe(::PROTOBUF_NAMESPACE_ID::int64 value);

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

  ::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::RepeatedPtrField<std::string> partition_tag_array_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
  ::PROTOBUF_NAMESPACE_ID::int64 topk_;
  ::PROTOBUF_NAMESPACE_ID::int64 nprobe_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_id_array_;
  ::milvus::grpc::SearchParam* search_param_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_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 =
    12;

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

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

  enum : int {
    kIdsFieldNumber = 3,
    kDistancesFieldNumber = 4,
    kStatusFieldNumber = 1,
    kRowNumFieldNumber = 2,
  };
  // repeated int64 ids = 3;
  int ids_size() const;
  void clear_ids();
  ::PROTOBUF_NAMESPACE_ID::int64 ids(int index) const;
  void set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
//  void add_ids(::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_ids(std::vector<::PROTOBUF_NAMESPACE_ID::int64>::const_iterator begin,
               std::vector<::PROTOBUF_NAMESPACE_ID::int64>::const_iterator end);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_ids();

  // repeated float distances = 4;
  int distances_size() const;
  void clear_distances();
  float distances(int index) const;
  void set_distances(int index, float value);
//  void add_distances(float value);
  void add_distances(std::vector<float>::const_iterator begin, std::vector<float>::const_iterator end);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      distances() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_distances();

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ids_;
  mutable std::atomic<int> _ids_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > distances_;
  mutable std::atomic<int> _distances_cached_byte_size_;
  ::milvus::grpc::Status* status_;
  ::PROTOBUF_NAMESPACE_ID::int64 row_num_;
  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 =
    13;

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

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

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

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

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

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

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

  public:

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

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

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_reply_;
  ::milvus::grpc::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_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 =
    14;

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

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

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

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

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

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

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

  public:

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

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

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::grpc::Status* status_;
  bool bool_reply_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_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 =
    15;

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

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

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

  // int64 table_row_count = 2;
  void clear_table_row_count();
  ::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 _Internal;

  ::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 =
    16;

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kIndexTypeFieldNumber = 1,
    kNlistFieldNumber = 2,
  };
  // int32 index_type = 1;
  void clear_index_type();
  ::PROTOBUF_NAMESPACE_ID::int32 index_type() const;
  void set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value);

  // int32 nlist = 2;
  void clear_nlist();
  ::PROTOBUF_NAMESPACE_ID::int32 nlist() const;
  void set_nlist(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int32 index_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 nlist_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kTableNameFieldNumber = 2,
    kStatusFieldNumber = 1,
    kIndexFieldNumber = 3,
  };
  // string table_name = 2;
  void clear_table_name();
  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();
  const ::milvus::grpc::Status& status() const;
  ::milvus::grpc::Status* release_status();
  ::milvus::grpc::Status* mutable_status();
  void set_allocated_status(::milvus::grpc::Status* status);

  // .milvus.grpc.Index index = 3;
  bool has_index() const;
  void clear_index();
  const ::milvus::grpc::Index& index() const;
  ::milvus::grpc::Index* release_index();
  ::milvus::grpc::Index* mutable_index();
  void set_allocated_index(::milvus::grpc::Index* index);

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kTableNameFieldNumber = 2,
    kRangeFieldNumber = 1,
  };
  // string table_name = 2;
  void clear_table_name();
  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.Range range = 1;
  bool has_range() const;
  void clear_range();
  const ::milvus::grpc::Range& range() const;
  ::milvus::grpc::Range* release_range();
  ::milvus::grpc::Range* mutable_range();
  void set_allocated_range(::milvus::grpc::Range* range);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
  ::milvus::grpc::Range* range_;
  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

// string table_name = 1;
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)
}

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

// PartitionName

// string partition_name = 1;
inline void PartitionName::clear_partition_name() {
  partition_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionName::partition_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionName.partition_name)
  return partition_name_.GetNoArena();
}
inline void PartitionName::set_partition_name(const std::string& value) {
  
  partition_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionName.partition_name)
}
inline void PartitionName::set_partition_name(std::string&& value) {
  
  partition_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionName.partition_name)
}
inline void PartitionName::set_partition_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  partition_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionName.partition_name)
}
inline void PartitionName::set_partition_name(const char* value, size_t size) {
  
  partition_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionName.partition_name)
}
inline std::string* PartitionName::mutable_partition_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionName.partition_name)
  return partition_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionName::release_partition_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.PartitionName.partition_name)
  
  return partition_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionName::set_allocated_partition_name(std::string* partition_name) {
  if (partition_name != nullptr) {
    
  } else {
    
  }
  partition_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionName.partition_name)
}

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

// TableNameList

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

// repeated string table_names = 2;
inline int TableNameList::table_names_size() const {
  return table_names_.size();
}
inline void TableNameList::clear_table_names() {
  table_names_.Clear();
}
inline const std::string& TableNameList::table_names(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.table_names)
  return table_names_.Get(index);
}
inline std::string* TableNameList::mutable_table_names(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.table_names)
  return table_names_.Mutable(index);
}
inline void TableNameList::set_table_names(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names)
  table_names_.Mutable(index)->assign(value);
}
inline void TableNameList::set_table_names(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names)
  table_names_.Mutable(index)->assign(std::move(value));
}
inline void TableNameList::set_table_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  table_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::set_table_names(int index, const char* value, size_t size) {
  table_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableNameList.table_names)
}
inline std::string* TableNameList::add_table_names() {
  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.TableNameList.table_names)
  return table_names_.Add();
}
inline void TableNameList::add_table_names(const std::string& value) {
  table_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::add_table_names(std::string&& value) {
  table_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::add_table_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  table_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::add_table_names(const char* value, size_t size) {
  table_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.TableNameList.table_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TableNameList::table_names() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.TableNameList.table_names)
  return table_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TableNameList::mutable_table_names() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableNameList.table_names)
  return &table_names_;
}

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

// TableSchema

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

// string table_name = 2;
inline void TableSchema::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TableSchema::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name)
  return table_name_.GetNoArena();
}
inline void TableSchema::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.table_name)
}
inline void TableSchema::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.TableSchema.table_name)
}
inline void TableSchema::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.TableSchema.table_name)
}
inline void TableSchema::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.TableSchema.table_name)
}
inline std::string* TableSchema::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TableSchema::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TableSchema::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.TableSchema.table_name)
}

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

// int64 index_file_size = 4;
inline void TableSchema::clear_index_file_size() {
  index_file_size_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::index_file_size() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.index_file_size)
  return index_file_size_;
}
inline void TableSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  index_file_size_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.index_file_size)
}

// int32 metric_type = 5;
inline void TableSchema::clear_metric_type() {
  metric_type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TableSchema::metric_type() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.metric_type)
  return metric_type_;
}
inline void TableSchema::set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  metric_type_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.metric_type)
}

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

// PartitionParam

// string table_name = 1;
inline void PartitionParam::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionParam::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.table_name)
  return table_name_.GetNoArena();
}
inline void PartitionParam::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.table_name)
}
inline void PartitionParam::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.PartitionParam.table_name)
}
inline void PartitionParam::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.PartitionParam.table_name)
}
inline void PartitionParam::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.PartitionParam.table_name)
}
inline std::string* PartitionParam::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionParam::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionParam::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.PartitionParam.table_name)
}

// string partition_name = 2;
inline void PartitionParam::clear_partition_name() {
  partition_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionParam::partition_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.partition_name)
  return partition_name_.GetNoArena();
}
inline void PartitionParam::set_partition_name(const std::string& value) {
  
  partition_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.partition_name)
}
inline void PartitionParam::set_partition_name(std::string&& value) {
  
  partition_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.partition_name)
}
inline void PartitionParam::set_partition_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  partition_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.partition_name)
}
inline void PartitionParam::set_partition_name(const char* value, size_t size) {
  
  partition_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.partition_name)
}
inline std::string* PartitionParam::mutable_partition_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.partition_name)
  return partition_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionParam::release_partition_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.partition_name)
  
  return partition_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionParam::set_allocated_partition_name(std::string* partition_name) {
  if (partition_name != nullptr) {
    
  } else {
    
  }
  partition_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.partition_name)
}

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

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

// PartitionList

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

// repeated .milvus.grpc.PartitionParam partition_array = 2;
inline int PartitionList::partition_array_size() const {
  return partition_array_.size();
}
inline void PartitionList::clear_partition_array() {
  partition_array_.Clear();
}
inline ::milvus::grpc::PartitionParam* PartitionList::mutable_partition_array(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionList.partition_array)
  return partition_array_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionParam >*
PartitionList::mutable_partition_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.PartitionList.partition_array)
  return &partition_array_;
}
inline const ::milvus::grpc::PartitionParam& PartitionList::partition_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.PartitionList.partition_array)
  return partition_array_.Get(index);
}
inline ::milvus::grpc::PartitionParam* PartitionList::add_partition_array() {
  // @@protoc_insertion_point(field_add:milvus.grpc.PartitionList.partition_array)
  return partition_array_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionParam >&
PartitionList::partition_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.PartitionList.partition_array)
  return partition_array_;
}

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

// 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 void RowRecord::add_vector_data(std::vector<float>::const_iterator begin,
                                       std::vector<float>::const_iterator end) {
    vector_data_.Add(begin, end);
    // @@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_;
}

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

// InsertParam

// string table_name = 1;
inline void InsertParam::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& InsertParam::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.table_name)
  return table_name_.GetNoArena();
}
inline void InsertParam::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.table_name)
}
inline void InsertParam::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.InsertParam.table_name)
}
inline void InsertParam::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.InsertParam.table_name)
}
inline void InsertParam::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.InsertParam.table_name)
}
inline std::string* InsertParam::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* InsertParam::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void InsertParam::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.InsertParam.table_name)
}

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

// repeated int64 row_id_array = 3;
inline int InsertParam::row_id_array_size() const {
  return row_id_array_.size();
}
inline void InsertParam::clear_row_id_array() {
  row_id_array_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 InsertParam::row_id_array(int index) const {
  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.row_id_array)
  return row_id_array_.Get(index);
}
inline void InsertParam::set_row_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  row_id_array_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.row_id_array)
}
//inline void InsertParam::add_row_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
//  row_id_array_.Add(value);
//  // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.row_id_array)
//}
inline void InsertParam::add_row_id_array(std::vector<::PROTOBUF_NAMESPACE_ID::int64>::const_iterator begin,
                                          std::vector<::PROTOBUF_NAMESPACE_ID::int64>::const_iterator end) {
    row_id_array_.Add(begin, end);
    // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.row_id_array)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
InsertParam::row_id_array() const {
  // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.row_id_array)
  return row_id_array_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
InsertParam::mutable_row_id_array() {
  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.row_id_array)
  return &row_id_array_;
}

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

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

// 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_;
}

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

// SearchParam

// string table_name = 1;
inline void SearchParam::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchParam::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.table_name)
  return table_name_.GetNoArena();
}
inline void SearchParam::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.table_name)
}
inline void SearchParam::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.SearchParam.table_name)
}
inline void SearchParam::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.SearchParam.table_name)
}
inline void SearchParam::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.SearchParam.table_name)
}
inline std::string* SearchParam::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchParam::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchParam::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.SearchParam.table_name)
}

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

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

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

// int64 nprobe = 5;
inline void SearchParam::clear_nprobe() {
  nprobe_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SearchParam::nprobe() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.nprobe)
  return nprobe_;
}
inline void SearchParam::set_nprobe(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  nprobe_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.nprobe)
}

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

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

// SearchInFilesParam

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

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

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

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

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

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

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

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

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

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

// Index

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

// int32 nlist = 2;
inline void Index::clear_nlist() {
  nlist_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Index::nlist() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.Index.nlist)
  return nlist_;
}
inline void Index::set_nlist(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  nlist_ = value;
  // @@protoc_insertion_point(field_set:milvus.grpc.Index.nlist)
}

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

// IndexParam

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

// string table_name = 2;
inline void IndexParam::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& IndexParam::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.table_name)
  return table_name_.GetNoArena();
}
inline void IndexParam::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.table_name)
}
inline void IndexParam::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.IndexParam.table_name)
}
inline void IndexParam::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.IndexParam.table_name)
}
inline void IndexParam::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.IndexParam.table_name)
}
inline std::string* IndexParam::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* IndexParam::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void IndexParam::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.IndexParam.table_name)
}

// .milvus.grpc.Index index = 3;
inline bool IndexParam::has_index() const {
  return this != internal_default_instance() && index_ != nullptr;
}
inline void IndexParam::clear_index() {
  if (GetArenaNoVirtual() == nullptr && index_ != nullptr) {
    delete index_;
  }
  index_ = nullptr;
}
inline const ::milvus::grpc::Index& IndexParam::index() const {
  const ::milvus::grpc::Index* p = index_;
  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.index)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Index*>(
      &::milvus::grpc::_Index_default_instance_);
}
inline ::milvus::grpc::Index* IndexParam::release_index() {
  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.index)
  
  ::milvus::grpc::Index* temp = index_;
  index_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Index* IndexParam::mutable_index() {
  
  if (index_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Index>(GetArenaNoVirtual());
    index_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.index)
  return index_;
}
inline void IndexParam::set_allocated_index(::milvus::grpc::Index* index) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete index_;
  }
  if (index) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, index, submessage_arena);
    }
    
  } else {
    
  }
  index_ = index;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.index)
}

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

// DeleteByDateParam

// .milvus.grpc.Range range = 1;
inline bool DeleteByDateParam::has_range() const {
  return this != internal_default_instance() && range_ != nullptr;
}
inline void DeleteByDateParam::clear_range() {
  if (GetArenaNoVirtual() == nullptr && range_ != nullptr) {
    delete range_;
  }
  range_ = nullptr;
}
inline const ::milvus::grpc::Range& DeleteByDateParam::range() const {
  const ::milvus::grpc::Range* p = range_;
  // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByDateParam.range)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Range*>(
      &::milvus::grpc::_Range_default_instance_);
}
inline ::milvus::grpc::Range* DeleteByDateParam::release_range() {
  // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByDateParam.range)
  
  ::milvus::grpc::Range* temp = range_;
  range_ = nullptr;
  return temp;
}
inline ::milvus::grpc::Range* DeleteByDateParam::mutable_range() {
  
  if (range_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::grpc::Range>(GetArenaNoVirtual());
    range_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByDateParam.range)
  return range_;
}
inline void DeleteByDateParam::set_allocated_range(::milvus::grpc::Range* range) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete range_;
  }
  if (range) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, range, submessage_arena);
    }
    
  } else {
    
  }
  range_ = range;
  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByDateParam.range)
}

// string table_name = 2;
inline void DeleteByDateParam::clear_table_name() {
  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DeleteByDateParam::table_name() const {
  // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByDateParam.table_name)
  return table_name_.GetNoArena();
}
inline void DeleteByDateParam::set_table_name(const std::string& value) {
  
  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByDateParam.table_name)
}
inline void DeleteByDateParam::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.DeleteByDateParam.table_name)
}
inline void DeleteByDateParam::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.DeleteByDateParam.table_name)
}
inline void DeleteByDateParam::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.DeleteByDateParam.table_name)
}
inline std::string* DeleteByDateParam::mutable_table_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByDateParam.table_name)
  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeleteByDateParam::release_table_name() {
  // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByDateParam.table_name)
  
  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeleteByDateParam::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.DeleteByDateParam.table_name)
}

#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