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

#ifndef GOOGLE_PROTOBUF_INCLUDED_schema_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_schema_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021004 < 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_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_schema_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_schema_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_schema_2eproto;
namespace milvus {
namespace proto {
namespace schema {
class BoolArray;
struct BoolArrayDefaultTypeInternal;
extern BoolArrayDefaultTypeInternal _BoolArray_default_instance_;
class BytesArray;
struct BytesArrayDefaultTypeInternal;
extern BytesArrayDefaultTypeInternal _BytesArray_default_instance_;
class CollectionSchema;
struct CollectionSchemaDefaultTypeInternal;
extern CollectionSchemaDefaultTypeInternal _CollectionSchema_default_instance_;
class DoubleArray;
struct DoubleArrayDefaultTypeInternal;
extern DoubleArrayDefaultTypeInternal _DoubleArray_default_instance_;
class FieldData;
struct FieldDataDefaultTypeInternal;
extern FieldDataDefaultTypeInternal _FieldData_default_instance_;
class FieldSchema;
struct FieldSchemaDefaultTypeInternal;
extern FieldSchemaDefaultTypeInternal _FieldSchema_default_instance_;
class FloatArray;
struct FloatArrayDefaultTypeInternal;
extern FloatArrayDefaultTypeInternal _FloatArray_default_instance_;
class IDs;
struct IDsDefaultTypeInternal;
extern IDsDefaultTypeInternal _IDs_default_instance_;
class IntArray;
struct IntArrayDefaultTypeInternal;
extern IntArrayDefaultTypeInternal _IntArray_default_instance_;
class LongArray;
struct LongArrayDefaultTypeInternal;
extern LongArrayDefaultTypeInternal _LongArray_default_instance_;
class ScalarField;
struct ScalarFieldDefaultTypeInternal;
extern ScalarFieldDefaultTypeInternal _ScalarField_default_instance_;
class SearchResultData;
struct SearchResultDataDefaultTypeInternal;
extern SearchResultDataDefaultTypeInternal _SearchResultData_default_instance_;
class StringArray;
struct StringArrayDefaultTypeInternal;
extern StringArrayDefaultTypeInternal _StringArray_default_instance_;
class VectorField;
struct VectorFieldDefaultTypeInternal;
extern VectorFieldDefaultTypeInternal _VectorField_default_instance_;
}  // namespace schema
}  // namespace proto
}  // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::proto::schema::BoolArray* Arena::CreateMaybeMessage<::milvus::proto::schema::BoolArray>(Arena*);
template<> ::milvus::proto::schema::BytesArray* Arena::CreateMaybeMessage<::milvus::proto::schema::BytesArray>(Arena*);
template<> ::milvus::proto::schema::CollectionSchema* Arena::CreateMaybeMessage<::milvus::proto::schema::CollectionSchema>(Arena*);
template<> ::milvus::proto::schema::DoubleArray* Arena::CreateMaybeMessage<::milvus::proto::schema::DoubleArray>(Arena*);
template<> ::milvus::proto::schema::FieldData* Arena::CreateMaybeMessage<::milvus::proto::schema::FieldData>(Arena*);
template<> ::milvus::proto::schema::FieldSchema* Arena::CreateMaybeMessage<::milvus::proto::schema::FieldSchema>(Arena*);
template<> ::milvus::proto::schema::FloatArray* Arena::CreateMaybeMessage<::milvus::proto::schema::FloatArray>(Arena*);
template<> ::milvus::proto::schema::IDs* Arena::CreateMaybeMessage<::milvus::proto::schema::IDs>(Arena*);
template<> ::milvus::proto::schema::IntArray* Arena::CreateMaybeMessage<::milvus::proto::schema::IntArray>(Arena*);
template<> ::milvus::proto::schema::LongArray* Arena::CreateMaybeMessage<::milvus::proto::schema::LongArray>(Arena*);
template<> ::milvus::proto::schema::ScalarField* Arena::CreateMaybeMessage<::milvus::proto::schema::ScalarField>(Arena*);
template<> ::milvus::proto::schema::SearchResultData* Arena::CreateMaybeMessage<::milvus::proto::schema::SearchResultData>(Arena*);
template<> ::milvus::proto::schema::StringArray* Arena::CreateMaybeMessage<::milvus::proto::schema::StringArray>(Arena*);
template<> ::milvus::proto::schema::VectorField* Arena::CreateMaybeMessage<::milvus::proto::schema::VectorField>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
namespace proto {
namespace schema {

enum DataType : int {
  None = 0,
  Bool = 1,
  Int8 = 2,
  Int16 = 3,
  Int32 = 4,
  Int64 = 5,
  Float = 10,
  Double = 11,
  String = 20,
  VarChar = 21,
  BinaryVector = 100,
  FloatVector = 101,
  DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool DataType_IsValid(int value);
constexpr DataType DataType_MIN = None;
constexpr DataType DataType_MAX = FloatVector;
constexpr int DataType_ARRAYSIZE = DataType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor();
template<typename T>
inline const std::string& DataType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DataType_descriptor(), enum_t_value);
}
inline bool DataType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataType>(
    DataType_descriptor(), name, value);
}
enum FieldState : int {
  FieldCreated = 0,
  FieldCreating = 1,
  FieldDropping = 2,
  FieldDropped = 3,
  FieldState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  FieldState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool FieldState_IsValid(int value);
constexpr FieldState FieldState_MIN = FieldCreated;
constexpr FieldState FieldState_MAX = FieldDropped;
constexpr int FieldState_ARRAYSIZE = FieldState_MAX + 1;

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

class FieldSchema final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.FieldSchema) */ {
 public:
  inline FieldSchema() : FieldSchema(nullptr) {}
  ~FieldSchema() override;
  explicit PROTOBUF_CONSTEXPR FieldSchema(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FieldSchema& operator=(const FieldSchema& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldSchema& operator=(FieldSchema&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FieldSchema& default_instance() {
    return *internal_default_instance();
  }
  static inline const FieldSchema* internal_default_instance() {
    return reinterpret_cast<const FieldSchema*>(
               &_FieldSchema_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(FieldSchema& a, FieldSchema& b) {
    a.Swap(&b);
  }
  inline void Swap(FieldSchema* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FieldSchema* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FieldSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FieldSchema>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FieldSchema& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FieldSchema& from) {
    FieldSchema::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FieldSchema* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.FieldSchema";
  }
  protected:
  explicit FieldSchema(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTypeParamsFieldNumber = 6,
    kIndexParamsFieldNumber = 7,
    kNameFieldNumber = 2,
    kDescriptionFieldNumber = 4,
    kFieldIDFieldNumber = 1,
    kDataTypeFieldNumber = 5,
    kIsPrimaryKeyFieldNumber = 3,
    kAutoIDFieldNumber = 8,
    kStateFieldNumber = 9,
  };
  // repeated .milvus.proto.common.KeyValuePair type_params = 6;
  int type_params_size() const;
  private:
  int _internal_type_params_size() const;
  public:
  void clear_type_params();
  ::milvus::proto::common::KeyValuePair* mutable_type_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
      mutable_type_params();
  private:
  const ::milvus::proto::common::KeyValuePair& _internal_type_params(int index) const;
  ::milvus::proto::common::KeyValuePair* _internal_add_type_params();
  public:
  const ::milvus::proto::common::KeyValuePair& type_params(int index) const;
  ::milvus::proto::common::KeyValuePair* add_type_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
      type_params() const;

  // repeated .milvus.proto.common.KeyValuePair index_params = 7;
  int index_params_size() const;
  private:
  int _internal_index_params_size() const;
  public:
  void clear_index_params();
  ::milvus::proto::common::KeyValuePair* mutable_index_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
      mutable_index_params();
  private:
  const ::milvus::proto::common::KeyValuePair& _internal_index_params(int index) const;
  ::milvus::proto::common::KeyValuePair* _internal_add_index_params();
  public:
  const ::milvus::proto::common::KeyValuePair& index_params(int index) const;
  ::milvus::proto::common::KeyValuePair* add_index_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
      index_params() const;

  // string name = 2;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string description = 4;
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // int64 fieldID = 1;
  void clear_fieldid();
  int64_t fieldid() const;
  void set_fieldid(int64_t value);
  private:
  int64_t _internal_fieldid() const;
  void _internal_set_fieldid(int64_t value);
  public:

  // .milvus.proto.schema.DataType data_type = 5;
  void clear_data_type();
  ::milvus::proto::schema::DataType data_type() const;
  void set_data_type(::milvus::proto::schema::DataType value);
  private:
  ::milvus::proto::schema::DataType _internal_data_type() const;
  void _internal_set_data_type(::milvus::proto::schema::DataType value);
  public:

  // bool is_primary_key = 3;
  void clear_is_primary_key();
  bool is_primary_key() const;
  void set_is_primary_key(bool value);
  private:
  bool _internal_is_primary_key() const;
  void _internal_set_is_primary_key(bool value);
  public:

  // bool autoID = 8;
  void clear_autoid();
  bool autoid() const;
  void set_autoid(bool value);
  private:
  bool _internal_autoid() const;
  void _internal_set_autoid(bool value);
  public:

  // .milvus.proto.schema.FieldState state = 9;
  void clear_state();
  ::milvus::proto::schema::FieldState state() const;
  void set_state(::milvus::proto::schema::FieldState value);
  private:
  ::milvus::proto::schema::FieldState _internal_state() const;
  void _internal_set_state(::milvus::proto::schema::FieldState value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.FieldSchema)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair > type_params_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair > index_params_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    int64_t fieldid_;
    int data_type_;
    bool is_primary_key_;
    bool autoid_;
    int state_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class CollectionSchema final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.CollectionSchema) */ {
 public:
  inline CollectionSchema() : CollectionSchema(nullptr) {}
  ~CollectionSchema() override;
  explicit PROTOBUF_CONSTEXPR CollectionSchema(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline CollectionSchema& operator=(const CollectionSchema& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollectionSchema& operator=(CollectionSchema&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CollectionSchema& default_instance() {
    return *internal_default_instance();
  }
  static inline const CollectionSchema* internal_default_instance() {
    return reinterpret_cast<const CollectionSchema*>(
               &_CollectionSchema_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CollectionSchema& a, CollectionSchema& b) {
    a.Swap(&b);
  }
  inline void Swap(CollectionSchema* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CollectionSchema* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CollectionSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CollectionSchema>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CollectionSchema& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CollectionSchema& from) {
    CollectionSchema::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CollectionSchema* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.CollectionSchema";
  }
  protected:
  explicit CollectionSchema(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFieldsFieldNumber = 4,
    kNameFieldNumber = 1,
    kDescriptionFieldNumber = 2,
    kAutoIDFieldNumber = 3,
  };
  // repeated .milvus.proto.schema.FieldSchema fields = 4;
  int fields_size() const;
  private:
  int _internal_fields_size() const;
  public:
  void clear_fields();
  ::milvus::proto::schema::FieldSchema* mutable_fields(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldSchema >*
      mutable_fields();
  private:
  const ::milvus::proto::schema::FieldSchema& _internal_fields(int index) const;
  ::milvus::proto::schema::FieldSchema* _internal_add_fields();
  public:
  const ::milvus::proto::schema::FieldSchema& fields(int index) const;
  ::milvus::proto::schema::FieldSchema* add_fields();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldSchema >&
      fields() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string description = 2;
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // bool autoID = 3;
  void clear_autoid();
  bool autoid() const;
  void set_autoid(bool value);
  private:
  bool _internal_autoid() const;
  void _internal_set_autoid(bool value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.CollectionSchema)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldSchema > fields_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    bool autoid_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class BoolArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.BoolArray) */ {
 public:
  inline BoolArray() : BoolArray(nullptr) {}
  ~BoolArray() override;
  explicit PROTOBUF_CONSTEXPR BoolArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BoolArray& operator=(const BoolArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolArray& operator=(BoolArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BoolArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const BoolArray* internal_default_instance() {
    return reinterpret_cast<const BoolArray*>(
               &_BoolArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(BoolArray& a, BoolArray& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BoolArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BoolArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BoolArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BoolArray& from) {
    BoolArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.BoolArray";
  }
  protected:
  explicit BoolArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated bool data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  bool _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_data() const;
  void _internal_add_data(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_data();
  public:
  bool data(int index) const;
  void set_data(int index, bool value);
  void add_data(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.BoolArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class IntArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.IntArray) */ {
 public:
  inline IntArray() : IntArray(nullptr) {}
  ~IntArray() override;
  explicit PROTOBUF_CONSTEXPR IntArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline IntArray& operator=(const IntArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntArray& operator=(IntArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IntArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const IntArray* internal_default_instance() {
    return reinterpret_cast<const IntArray*>(
               &_IntArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(IntArray& a, IntArray& b) {
    a.Swap(&b);
  }
  inline void Swap(IntArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  IntArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IntArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IntArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IntArray& from) {
    IntArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.IntArray";
  }
  protected:
  explicit IntArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated int32 data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  int32_t _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_data() const;
  void _internal_add_data(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_data();
  public:
  int32_t data(int index) const;
  void set_data(int index, int32_t value);
  void add_data(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.IntArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > data_;
    mutable std::atomic<int> _data_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class LongArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.LongArray) */ {
 public:
  inline LongArray() : LongArray(nullptr) {}
  ~LongArray() override;
  explicit PROTOBUF_CONSTEXPR LongArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LongArray& operator=(const LongArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline LongArray& operator=(LongArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LongArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const LongArray* internal_default_instance() {
    return reinterpret_cast<const LongArray*>(
               &_LongArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(LongArray& a, LongArray& b) {
    a.Swap(&b);
  }
  inline void Swap(LongArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LongArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LongArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LongArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LongArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LongArray& from) {
    LongArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LongArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.LongArray";
  }
  protected:
  explicit LongArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated int64 data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  int64_t _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_data() const;
  void _internal_add_data(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_data();
  public:
  int64_t data(int index) const;
  void set_data(int index, int64_t value);
  void add_data(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.LongArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > data_;
    mutable std::atomic<int> _data_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class FloatArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.FloatArray) */ {
 public:
  inline FloatArray() : FloatArray(nullptr) {}
  ~FloatArray() override;
  explicit PROTOBUF_CONSTEXPR FloatArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FloatArray& operator=(const FloatArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline FloatArray& operator=(FloatArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FloatArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const FloatArray* internal_default_instance() {
    return reinterpret_cast<const FloatArray*>(
               &_FloatArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(FloatArray& a, FloatArray& b) {
    a.Swap(&b);
  }
  inline void Swap(FloatArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FloatArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FloatArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FloatArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FloatArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FloatArray& from) {
    FloatArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FloatArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.FloatArray";
  }
  protected:
  explicit FloatArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated float data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  float _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_data() const;
  void _internal_add_data(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_data();
  public:
  float data(int index) const;
  void set_data(int index, float value);
  void add_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.FloatArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class DoubleArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.DoubleArray) */ {
 public:
  inline DoubleArray() : DoubleArray(nullptr) {}
  ~DoubleArray() override;
  explicit PROTOBUF_CONSTEXPR DoubleArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DoubleArray& operator=(const DoubleArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline DoubleArray& operator=(DoubleArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DoubleArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const DoubleArray* internal_default_instance() {
    return reinterpret_cast<const DoubleArray*>(
               &_DoubleArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(DoubleArray& a, DoubleArray& b) {
    a.Swap(&b);
  }
  inline void Swap(DoubleArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DoubleArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DoubleArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DoubleArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DoubleArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DoubleArray& from) {
    DoubleArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DoubleArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.DoubleArray";
  }
  protected:
  explicit DoubleArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated double data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  double _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_data() const;
  void _internal_add_data(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_data();
  public:
  double data(int index) const;
  void set_data(int index, double value);
  void add_data(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.DoubleArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class BytesArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.BytesArray) */ {
 public:
  inline BytesArray() : BytesArray(nullptr) {}
  ~BytesArray() override;
  explicit PROTOBUF_CONSTEXPR BytesArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BytesArray& operator=(const BytesArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline BytesArray& operator=(BytesArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BytesArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const BytesArray* internal_default_instance() {
    return reinterpret_cast<const BytesArray*>(
               &_BytesArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(BytesArray& a, BytesArray& b) {
    a.Swap(&b);
  }
  inline void Swap(BytesArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BytesArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BytesArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BytesArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BytesArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BytesArray& from) {
    BytesArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BytesArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.BytesArray";
  }
  protected:
  explicit BytesArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated bytes data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  const std::string& data(int index) const;
  std::string* mutable_data(int index);
  void set_data(int index, const std::string& value);
  void set_data(int index, std::string&& value);
  void set_data(int index, const char* value);
  void set_data(int index, const void* value, size_t size);
  std::string* add_data();
  void add_data(const std::string& value);
  void add_data(std::string&& value);
  void add_data(const char* value);
  void add_data(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_data();
  private:
  const std::string& _internal_data(int index) const;
  std::string* _internal_add_data();
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.BytesArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class StringArray final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.StringArray) */ {
 public:
  inline StringArray() : StringArray(nullptr) {}
  ~StringArray() override;
  explicit PROTOBUF_CONSTEXPR StringArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline StringArray& operator=(const StringArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringArray& operator=(StringArray&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StringArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const StringArray* internal_default_instance() {
    return reinterpret_cast<const StringArray*>(
               &_StringArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(StringArray& a, StringArray& b) {
    a.Swap(&b);
  }
  inline void Swap(StringArray* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StringArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  StringArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<StringArray>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const StringArray& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const StringArray& from) {
    StringArray::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringArray* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.StringArray";
  }
  protected:
  explicit StringArray(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated string data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  const std::string& data(int index) const;
  std::string* mutable_data(int index);
  void set_data(int index, const std::string& value);
  void set_data(int index, std::string&& value);
  void set_data(int index, const char* value);
  void set_data(int index, const char* value, size_t size);
  std::string* add_data();
  void add_data(const std::string& value);
  void add_data(std::string&& value);
  void add_data(const char* value);
  void add_data(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_data();
  private:
  const std::string& _internal_data(int index) const;
  std::string* _internal_add_data();
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.StringArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class ScalarField final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.ScalarField) */ {
 public:
  inline ScalarField() : ScalarField(nullptr) {}
  ~ScalarField() override;
  explicit PROTOBUF_CONSTEXPR ScalarField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ScalarField& operator=(const ScalarField& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScalarField& operator=(ScalarField&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScalarField& default_instance() {
    return *internal_default_instance();
  }
  enum DataCase {
    kBoolData = 1,
    kIntData = 2,
    kLongData = 3,
    kFloatData = 4,
    kDoubleData = 5,
    kStringData = 6,
    kBytesData = 7,
    DATA_NOT_SET = 0,
  };

  static inline const ScalarField* internal_default_instance() {
    return reinterpret_cast<const ScalarField*>(
               &_ScalarField_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(ScalarField& a, ScalarField& b) {
    a.Swap(&b);
  }
  inline void Swap(ScalarField* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScalarField* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ScalarField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ScalarField>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ScalarField& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ScalarField& from) {
    ScalarField::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ScalarField* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.ScalarField";
  }
  protected:
  explicit ScalarField(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kBoolDataFieldNumber = 1,
    kIntDataFieldNumber = 2,
    kLongDataFieldNumber = 3,
    kFloatDataFieldNumber = 4,
    kDoubleDataFieldNumber = 5,
    kStringDataFieldNumber = 6,
    kBytesDataFieldNumber = 7,
  };
  // .milvus.proto.schema.BoolArray bool_data = 1;
  bool has_bool_data() const;
  private:
  bool _internal_has_bool_data() const;
  public:
  void clear_bool_data();
  const ::milvus::proto::schema::BoolArray& bool_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::BoolArray* release_bool_data();
  ::milvus::proto::schema::BoolArray* mutable_bool_data();
  void set_allocated_bool_data(::milvus::proto::schema::BoolArray* bool_data);
  private:
  const ::milvus::proto::schema::BoolArray& _internal_bool_data() const;
  ::milvus::proto::schema::BoolArray* _internal_mutable_bool_data();
  public:
  void unsafe_arena_set_allocated_bool_data(
      ::milvus::proto::schema::BoolArray* bool_data);
  ::milvus::proto::schema::BoolArray* unsafe_arena_release_bool_data();

  // .milvus.proto.schema.IntArray int_data = 2;
  bool has_int_data() const;
  private:
  bool _internal_has_int_data() const;
  public:
  void clear_int_data();
  const ::milvus::proto::schema::IntArray& int_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::IntArray* release_int_data();
  ::milvus::proto::schema::IntArray* mutable_int_data();
  void set_allocated_int_data(::milvus::proto::schema::IntArray* int_data);
  private:
  const ::milvus::proto::schema::IntArray& _internal_int_data() const;
  ::milvus::proto::schema::IntArray* _internal_mutable_int_data();
  public:
  void unsafe_arena_set_allocated_int_data(
      ::milvus::proto::schema::IntArray* int_data);
  ::milvus::proto::schema::IntArray* unsafe_arena_release_int_data();

  // .milvus.proto.schema.LongArray long_data = 3;
  bool has_long_data() const;
  private:
  bool _internal_has_long_data() const;
  public:
  void clear_long_data();
  const ::milvus::proto::schema::LongArray& long_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::LongArray* release_long_data();
  ::milvus::proto::schema::LongArray* mutable_long_data();
  void set_allocated_long_data(::milvus::proto::schema::LongArray* long_data);
  private:
  const ::milvus::proto::schema::LongArray& _internal_long_data() const;
  ::milvus::proto::schema::LongArray* _internal_mutable_long_data();
  public:
  void unsafe_arena_set_allocated_long_data(
      ::milvus::proto::schema::LongArray* long_data);
  ::milvus::proto::schema::LongArray* unsafe_arena_release_long_data();

  // .milvus.proto.schema.FloatArray float_data = 4;
  bool has_float_data() const;
  private:
  bool _internal_has_float_data() const;
  public:
  void clear_float_data();
  const ::milvus::proto::schema::FloatArray& float_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::FloatArray* release_float_data();
  ::milvus::proto::schema::FloatArray* mutable_float_data();
  void set_allocated_float_data(::milvus::proto::schema::FloatArray* float_data);
  private:
  const ::milvus::proto::schema::FloatArray& _internal_float_data() const;
  ::milvus::proto::schema::FloatArray* _internal_mutable_float_data();
  public:
  void unsafe_arena_set_allocated_float_data(
      ::milvus::proto::schema::FloatArray* float_data);
  ::milvus::proto::schema::FloatArray* unsafe_arena_release_float_data();

  // .milvus.proto.schema.DoubleArray double_data = 5;
  bool has_double_data() const;
  private:
  bool _internal_has_double_data() const;
  public:
  void clear_double_data();
  const ::milvus::proto::schema::DoubleArray& double_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::DoubleArray* release_double_data();
  ::milvus::proto::schema::DoubleArray* mutable_double_data();
  void set_allocated_double_data(::milvus::proto::schema::DoubleArray* double_data);
  private:
  const ::milvus::proto::schema::DoubleArray& _internal_double_data() const;
  ::milvus::proto::schema::DoubleArray* _internal_mutable_double_data();
  public:
  void unsafe_arena_set_allocated_double_data(
      ::milvus::proto::schema::DoubleArray* double_data);
  ::milvus::proto::schema::DoubleArray* unsafe_arena_release_double_data();

  // .milvus.proto.schema.StringArray string_data = 6;
  bool has_string_data() const;
  private:
  bool _internal_has_string_data() const;
  public:
  void clear_string_data();
  const ::milvus::proto::schema::StringArray& string_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::StringArray* release_string_data();
  ::milvus::proto::schema::StringArray* mutable_string_data();
  void set_allocated_string_data(::milvus::proto::schema::StringArray* string_data);
  private:
  const ::milvus::proto::schema::StringArray& _internal_string_data() const;
  ::milvus::proto::schema::StringArray* _internal_mutable_string_data();
  public:
  void unsafe_arena_set_allocated_string_data(
      ::milvus::proto::schema::StringArray* string_data);
  ::milvus::proto::schema::StringArray* unsafe_arena_release_string_data();

  // .milvus.proto.schema.BytesArray bytes_data = 7;
  bool has_bytes_data() const;
  private:
  bool _internal_has_bytes_data() const;
  public:
  void clear_bytes_data();
  const ::milvus::proto::schema::BytesArray& bytes_data() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::BytesArray* release_bytes_data();
  ::milvus::proto::schema::BytesArray* mutable_bytes_data();
  void set_allocated_bytes_data(::milvus::proto::schema::BytesArray* bytes_data);
  private:
  const ::milvus::proto::schema::BytesArray& _internal_bytes_data() const;
  ::milvus::proto::schema::BytesArray* _internal_mutable_bytes_data();
  public:
  void unsafe_arena_set_allocated_bytes_data(
      ::milvus::proto::schema::BytesArray* bytes_data);
  ::milvus::proto::schema::BytesArray* unsafe_arena_release_bytes_data();

  void clear_data();
  DataCase data_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.schema.ScalarField)
 private:
  class _Internal;
  void set_has_bool_data();
  void set_has_int_data();
  void set_has_long_data();
  void set_has_float_data();
  void set_has_double_data();
  void set_has_string_data();
  void set_has_bytes_data();

  inline bool has_data() const;
  inline void clear_has_data();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union DataUnion {
      constexpr DataUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::milvus::proto::schema::BoolArray* bool_data_;
      ::milvus::proto::schema::IntArray* int_data_;
      ::milvus::proto::schema::LongArray* long_data_;
      ::milvus::proto::schema::FloatArray* float_data_;
      ::milvus::proto::schema::DoubleArray* double_data_;
      ::milvus::proto::schema::StringArray* string_data_;
      ::milvus::proto::schema::BytesArray* bytes_data_;
    } data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class VectorField final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.VectorField) */ {
 public:
  inline VectorField() : VectorField(nullptr) {}
  ~VectorField() override;
  explicit PROTOBUF_CONSTEXPR VectorField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline VectorField& operator=(const VectorField& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorField& operator=(VectorField&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VectorField& default_instance() {
    return *internal_default_instance();
  }
  enum DataCase {
    kFloatVector = 2,
    kBinaryVector = 3,
    DATA_NOT_SET = 0,
  };

  static inline const VectorField* internal_default_instance() {
    return reinterpret_cast<const VectorField*>(
               &_VectorField_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(VectorField& a, VectorField& b) {
    a.Swap(&b);
  }
  inline void Swap(VectorField* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VectorField* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  VectorField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VectorField>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VectorField& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const VectorField& from) {
    VectorField::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VectorField* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.VectorField";
  }
  protected:
  explicit VectorField(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDimFieldNumber = 1,
    kFloatVectorFieldNumber = 2,
    kBinaryVectorFieldNumber = 3,
  };
  // int64 dim = 1;
  void clear_dim();
  int64_t dim() const;
  void set_dim(int64_t value);
  private:
  int64_t _internal_dim() const;
  void _internal_set_dim(int64_t value);
  public:

  // .milvus.proto.schema.FloatArray float_vector = 2;
  bool has_float_vector() const;
  private:
  bool _internal_has_float_vector() const;
  public:
  void clear_float_vector();
  const ::milvus::proto::schema::FloatArray& float_vector() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::FloatArray* release_float_vector();
  ::milvus::proto::schema::FloatArray* mutable_float_vector();
  void set_allocated_float_vector(::milvus::proto::schema::FloatArray* float_vector);
  private:
  const ::milvus::proto::schema::FloatArray& _internal_float_vector() const;
  ::milvus::proto::schema::FloatArray* _internal_mutable_float_vector();
  public:
  void unsafe_arena_set_allocated_float_vector(
      ::milvus::proto::schema::FloatArray* float_vector);
  ::milvus::proto::schema::FloatArray* unsafe_arena_release_float_vector();

  // bytes binary_vector = 3;
  bool has_binary_vector() const;
  private:
  bool _internal_has_binary_vector() const;
  public:
  void clear_binary_vector();
  const std::string& binary_vector() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_binary_vector(ArgT0&& arg0, ArgT... args);
  std::string* mutable_binary_vector();
  PROTOBUF_NODISCARD std::string* release_binary_vector();
  void set_allocated_binary_vector(std::string* binary_vector);
  private:
  const std::string& _internal_binary_vector() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary_vector(const std::string& value);
  std::string* _internal_mutable_binary_vector();
  public:

  void clear_data();
  DataCase data_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.schema.VectorField)
 private:
  class _Internal;
  void set_has_float_vector();
  void set_has_binary_vector();

  inline bool has_data() const;
  inline void clear_has_data();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t dim_;
    union DataUnion {
      constexpr DataUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::milvus::proto::schema::FloatArray* float_vector_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_vector_;
    } data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class FieldData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.FieldData) */ {
 public:
  inline FieldData() : FieldData(nullptr) {}
  ~FieldData() override;
  explicit PROTOBUF_CONSTEXPR FieldData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FieldData& operator=(const FieldData& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldData& operator=(FieldData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FieldData& default_instance() {
    return *internal_default_instance();
  }
  enum FieldCase {
    kScalars = 3,
    kVectors = 4,
    FIELD_NOT_SET = 0,
  };

  static inline const FieldData* internal_default_instance() {
    return reinterpret_cast<const FieldData*>(
               &_FieldData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(FieldData& a, FieldData& b) {
    a.Swap(&b);
  }
  inline void Swap(FieldData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FieldData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FieldData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FieldData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FieldData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FieldData& from) {
    FieldData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FieldData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.FieldData";
  }
  protected:
  explicit FieldData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFieldNameFieldNumber = 2,
    kFieldIdFieldNumber = 5,
    kTypeFieldNumber = 1,
    kScalarsFieldNumber = 3,
    kVectorsFieldNumber = 4,
  };
  // string field_name = 2;
  void clear_field_name();
  const std::string& field_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_field_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_field_name();
  PROTOBUF_NODISCARD std::string* release_field_name();
  void set_allocated_field_name(std::string* field_name);
  private:
  const std::string& _internal_field_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_field_name(const std::string& value);
  std::string* _internal_mutable_field_name();
  public:

  // int64 field_id = 5;
  void clear_field_id();
  int64_t field_id() const;
  void set_field_id(int64_t value);
  private:
  int64_t _internal_field_id() const;
  void _internal_set_field_id(int64_t value);
  public:

  // .milvus.proto.schema.DataType type = 1;
  void clear_type();
  ::milvus::proto::schema::DataType type() const;
  void set_type(::milvus::proto::schema::DataType value);
  private:
  ::milvus::proto::schema::DataType _internal_type() const;
  void _internal_set_type(::milvus::proto::schema::DataType value);
  public:

  // .milvus.proto.schema.ScalarField scalars = 3;
  bool has_scalars() const;
  private:
  bool _internal_has_scalars() const;
  public:
  void clear_scalars();
  const ::milvus::proto::schema::ScalarField& scalars() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::ScalarField* release_scalars();
  ::milvus::proto::schema::ScalarField* mutable_scalars();
  void set_allocated_scalars(::milvus::proto::schema::ScalarField* scalars);
  private:
  const ::milvus::proto::schema::ScalarField& _internal_scalars() const;
  ::milvus::proto::schema::ScalarField* _internal_mutable_scalars();
  public:
  void unsafe_arena_set_allocated_scalars(
      ::milvus::proto::schema::ScalarField* scalars);
  ::milvus::proto::schema::ScalarField* unsafe_arena_release_scalars();

  // .milvus.proto.schema.VectorField vectors = 4;
  bool has_vectors() const;
  private:
  bool _internal_has_vectors() const;
  public:
  void clear_vectors();
  const ::milvus::proto::schema::VectorField& vectors() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::VectorField* release_vectors();
  ::milvus::proto::schema::VectorField* mutable_vectors();
  void set_allocated_vectors(::milvus::proto::schema::VectorField* vectors);
  private:
  const ::milvus::proto::schema::VectorField& _internal_vectors() const;
  ::milvus::proto::schema::VectorField* _internal_mutable_vectors();
  public:
  void unsafe_arena_set_allocated_vectors(
      ::milvus::proto::schema::VectorField* vectors);
  ::milvus::proto::schema::VectorField* unsafe_arena_release_vectors();

  void clear_field();
  FieldCase field_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.schema.FieldData)
 private:
  class _Internal;
  void set_has_scalars();
  void set_has_vectors();

  inline bool has_field() const;
  inline void clear_has_field();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_;
    int64_t field_id_;
    int type_;
    union FieldUnion {
      constexpr FieldUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::milvus::proto::schema::ScalarField* scalars_;
      ::milvus::proto::schema::VectorField* vectors_;
    } field_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class IDs final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.IDs) */ {
 public:
  inline IDs() : IDs(nullptr) {}
  ~IDs() override;
  explicit PROTOBUF_CONSTEXPR IDs(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline IDs& operator=(const IDs& from) {
    CopyFrom(from);
    return *this;
  }
  inline IDs& operator=(IDs&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IDs& default_instance() {
    return *internal_default_instance();
  }
  enum IdFieldCase {
    kIntId = 1,
    kStrId = 2,
    ID_FIELD_NOT_SET = 0,
  };

  static inline const IDs* internal_default_instance() {
    return reinterpret_cast<const IDs*>(
               &_IDs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(IDs& a, IDs& b) {
    a.Swap(&b);
  }
  inline void Swap(IDs* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IDs* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  IDs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IDs>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IDs& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IDs& from) {
    IDs::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IDs* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.IDs";
  }
  protected:
  explicit IDs(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIntIdFieldNumber = 1,
    kStrIdFieldNumber = 2,
  };
  // .milvus.proto.schema.LongArray int_id = 1;
  bool has_int_id() const;
  private:
  bool _internal_has_int_id() const;
  public:
  void clear_int_id();
  const ::milvus::proto::schema::LongArray& int_id() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::LongArray* release_int_id();
  ::milvus::proto::schema::LongArray* mutable_int_id();
  void set_allocated_int_id(::milvus::proto::schema::LongArray* int_id);
  private:
  const ::milvus::proto::schema::LongArray& _internal_int_id() const;
  ::milvus::proto::schema::LongArray* _internal_mutable_int_id();
  public:
  void unsafe_arena_set_allocated_int_id(
      ::milvus::proto::schema::LongArray* int_id);
  ::milvus::proto::schema::LongArray* unsafe_arena_release_int_id();

  // .milvus.proto.schema.StringArray str_id = 2;
  bool has_str_id() const;
  private:
  bool _internal_has_str_id() const;
  public:
  void clear_str_id();
  const ::milvus::proto::schema::StringArray& str_id() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::StringArray* release_str_id();
  ::milvus::proto::schema::StringArray* mutable_str_id();
  void set_allocated_str_id(::milvus::proto::schema::StringArray* str_id);
  private:
  const ::milvus::proto::schema::StringArray& _internal_str_id() const;
  ::milvus::proto::schema::StringArray* _internal_mutable_str_id();
  public:
  void unsafe_arena_set_allocated_str_id(
      ::milvus::proto::schema::StringArray* str_id);
  ::milvus::proto::schema::StringArray* unsafe_arena_release_str_id();

  void clear_id_field();
  IdFieldCase id_field_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.schema.IDs)
 private:
  class _Internal;
  void set_has_int_id();
  void set_has_str_id();

  inline bool has_id_field() const;
  inline void clear_has_id_field();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union IdFieldUnion {
      constexpr IdFieldUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::milvus::proto::schema::LongArray* int_id_;
      ::milvus::proto::schema::StringArray* str_id_;
    } id_field_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// -------------------------------------------------------------------

class SearchResultData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.schema.SearchResultData) */ {
 public:
  inline SearchResultData() : SearchResultData(nullptr) {}
  ~SearchResultData() override;
  explicit PROTOBUF_CONSTEXPR SearchResultData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SearchResultData& operator=(const SearchResultData& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchResultData& operator=(SearchResultData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SearchResultData& default_instance() {
    return *internal_default_instance();
  }
  static inline const SearchResultData* internal_default_instance() {
    return reinterpret_cast<const SearchResultData*>(
               &_SearchResultData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(SearchResultData& a, SearchResultData& b) {
    a.Swap(&b);
  }
  inline void Swap(SearchResultData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SearchResultData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SearchResultData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SearchResultData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SearchResultData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SearchResultData& from) {
    SearchResultData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SearchResultData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.schema.SearchResultData";
  }
  protected:
  explicit SearchResultData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFieldsDataFieldNumber = 3,
    kScoresFieldNumber = 4,
    kTopksFieldNumber = 6,
    kIdsFieldNumber = 5,
    kNumQueriesFieldNumber = 1,
    kTopKFieldNumber = 2,
  };
  // repeated .milvus.proto.schema.FieldData fields_data = 3;
  int fields_data_size() const;
  private:
  int _internal_fields_data_size() const;
  public:
  void clear_fields_data();
  ::milvus::proto::schema::FieldData* mutable_fields_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >*
      mutable_fields_data();
  private:
  const ::milvus::proto::schema::FieldData& _internal_fields_data(int index) const;
  ::milvus::proto::schema::FieldData* _internal_add_fields_data();
  public:
  const ::milvus::proto::schema::FieldData& fields_data(int index) const;
  ::milvus::proto::schema::FieldData* add_fields_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >&
      fields_data() const;

  // repeated float scores = 4;
  int scores_size() const;
  private:
  int _internal_scores_size() const;
  public:
  void clear_scores();
  private:
  float _internal_scores(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_scores() const;
  void _internal_add_scores(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_scores();
  public:
  float scores(int index) const;
  void set_scores(int index, float value);
  void add_scores(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      scores() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_scores();

  // repeated int64 topks = 6;
  int topks_size() const;
  private:
  int _internal_topks_size() const;
  public:
  void clear_topks();
  private:
  int64_t _internal_topks(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_topks() const;
  void _internal_add_topks(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_topks();
  public:
  int64_t topks(int index) const;
  void set_topks(int index, int64_t value);
  void add_topks(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      topks() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_topks();

  // .milvus.proto.schema.IDs ids = 5;
  bool has_ids() const;
  private:
  bool _internal_has_ids() const;
  public:
  void clear_ids();
  const ::milvus::proto::schema::IDs& ids() const;
  PROTOBUF_NODISCARD ::milvus::proto::schema::IDs* release_ids();
  ::milvus::proto::schema::IDs* mutable_ids();
  void set_allocated_ids(::milvus::proto::schema::IDs* ids);
  private:
  const ::milvus::proto::schema::IDs& _internal_ids() const;
  ::milvus::proto::schema::IDs* _internal_mutable_ids();
  public:
  void unsafe_arena_set_allocated_ids(
      ::milvus::proto::schema::IDs* ids);
  ::milvus::proto::schema::IDs* unsafe_arena_release_ids();

  // int64 num_queries = 1;
  void clear_num_queries();
  int64_t num_queries() const;
  void set_num_queries(int64_t value);
  private:
  int64_t _internal_num_queries() const;
  void _internal_set_num_queries(int64_t value);
  public:

  // int64 top_k = 2;
  void clear_top_k();
  int64_t top_k() const;
  void set_top_k(int64_t value);
  private:
  int64_t _internal_top_k() const;
  void _internal_set_top_k(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.schema.SearchResultData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData > fields_data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scores_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > topks_;
    mutable std::atomic<int> _topks_cached_byte_size_;
    ::milvus::proto::schema::IDs* ids_;
    int64_t num_queries_;
    int64_t top_k_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_schema_2eproto;
};
// ===================================================================


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

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

// int64 fieldID = 1;
inline void FieldSchema::clear_fieldid() {
  _impl_.fieldid_ = int64_t{0};
}
inline int64_t FieldSchema::_internal_fieldid() const {
  return _impl_.fieldid_;
}
inline int64_t FieldSchema::fieldid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.fieldID)
  return _internal_fieldid();
}
inline void FieldSchema::_internal_set_fieldid(int64_t value) {
  
  _impl_.fieldid_ = value;
}
inline void FieldSchema::set_fieldid(int64_t value) {
  _internal_set_fieldid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.fieldID)
}

// string name = 2;
inline void FieldSchema::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& FieldSchema::name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldSchema::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.name)
}
inline std::string* FieldSchema::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldSchema.name)
  return _s;
}
inline const std::string& FieldSchema::_internal_name() const {
  return _impl_.name_.Get();
}
inline void FieldSchema::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* FieldSchema::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* FieldSchema::release_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.FieldSchema.name)
  return _impl_.name_.Release();
}
inline void FieldSchema::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.FieldSchema.name)
}

// bool is_primary_key = 3;
inline void FieldSchema::clear_is_primary_key() {
  _impl_.is_primary_key_ = false;
}
inline bool FieldSchema::_internal_is_primary_key() const {
  return _impl_.is_primary_key_;
}
inline bool FieldSchema::is_primary_key() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.is_primary_key)
  return _internal_is_primary_key();
}
inline void FieldSchema::_internal_set_is_primary_key(bool value) {
  
  _impl_.is_primary_key_ = value;
}
inline void FieldSchema::set_is_primary_key(bool value) {
  _internal_set_is_primary_key(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.is_primary_key)
}

// string description = 4;
inline void FieldSchema::clear_description() {
  _impl_.description_.ClearToEmpty();
}
inline const std::string& FieldSchema::description() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldSchema::set_description(ArgT0&& arg0, ArgT... args) {
 
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.description)
}
inline std::string* FieldSchema::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldSchema.description)
  return _s;
}
inline const std::string& FieldSchema::_internal_description() const {
  return _impl_.description_.Get();
}
inline void FieldSchema::_internal_set_description(const std::string& value) {
  
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* FieldSchema::_internal_mutable_description() {
  
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* FieldSchema::release_description() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.FieldSchema.description)
  return _impl_.description_.Release();
}
inline void FieldSchema::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.FieldSchema.description)
}

// .milvus.proto.schema.DataType data_type = 5;
inline void FieldSchema::clear_data_type() {
  _impl_.data_type_ = 0;
}
inline ::milvus::proto::schema::DataType FieldSchema::_internal_data_type() const {
  return static_cast< ::milvus::proto::schema::DataType >(_impl_.data_type_);
}
inline ::milvus::proto::schema::DataType FieldSchema::data_type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.data_type)
  return _internal_data_type();
}
inline void FieldSchema::_internal_set_data_type(::milvus::proto::schema::DataType value) {
  
  _impl_.data_type_ = value;
}
inline void FieldSchema::set_data_type(::milvus::proto::schema::DataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.data_type)
}

// repeated .milvus.proto.common.KeyValuePair type_params = 6;
inline int FieldSchema::_internal_type_params_size() const {
  return _impl_.type_params_.size();
}
inline int FieldSchema::type_params_size() const {
  return _internal_type_params_size();
}
inline ::milvus::proto::common::KeyValuePair* FieldSchema::mutable_type_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldSchema.type_params)
  return _impl_.type_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
FieldSchema::mutable_type_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.FieldSchema.type_params)
  return &_impl_.type_params_;
}
inline const ::milvus::proto::common::KeyValuePair& FieldSchema::_internal_type_params(int index) const {
  return _impl_.type_params_.Get(index);
}
inline const ::milvus::proto::common::KeyValuePair& FieldSchema::type_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.type_params)
  return _internal_type_params(index);
}
inline ::milvus::proto::common::KeyValuePair* FieldSchema::_internal_add_type_params() {
  return _impl_.type_params_.Add();
}
inline ::milvus::proto::common::KeyValuePair* FieldSchema::add_type_params() {
  ::milvus::proto::common::KeyValuePair* _add = _internal_add_type_params();
  // @@protoc_insertion_point(field_add:milvus.proto.schema.FieldSchema.type_params)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
FieldSchema::type_params() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.FieldSchema.type_params)
  return _impl_.type_params_;
}

// repeated .milvus.proto.common.KeyValuePair index_params = 7;
inline int FieldSchema::_internal_index_params_size() const {
  return _impl_.index_params_.size();
}
inline int FieldSchema::index_params_size() const {
  return _internal_index_params_size();
}
inline ::milvus::proto::common::KeyValuePair* FieldSchema::mutable_index_params(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldSchema.index_params)
  return _impl_.index_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
FieldSchema::mutable_index_params() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.FieldSchema.index_params)
  return &_impl_.index_params_;
}
inline const ::milvus::proto::common::KeyValuePair& FieldSchema::_internal_index_params(int index) const {
  return _impl_.index_params_.Get(index);
}
inline const ::milvus::proto::common::KeyValuePair& FieldSchema::index_params(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.index_params)
  return _internal_index_params(index);
}
inline ::milvus::proto::common::KeyValuePair* FieldSchema::_internal_add_index_params() {
  return _impl_.index_params_.Add();
}
inline ::milvus::proto::common::KeyValuePair* FieldSchema::add_index_params() {
  ::milvus::proto::common::KeyValuePair* _add = _internal_add_index_params();
  // @@protoc_insertion_point(field_add:milvus.proto.schema.FieldSchema.index_params)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
FieldSchema::index_params() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.FieldSchema.index_params)
  return _impl_.index_params_;
}

// bool autoID = 8;
inline void FieldSchema::clear_autoid() {
  _impl_.autoid_ = false;
}
inline bool FieldSchema::_internal_autoid() const {
  return _impl_.autoid_;
}
inline bool FieldSchema::autoid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.autoID)
  return _internal_autoid();
}
inline void FieldSchema::_internal_set_autoid(bool value) {
  
  _impl_.autoid_ = value;
}
inline void FieldSchema::set_autoid(bool value) {
  _internal_set_autoid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.autoID)
}

// .milvus.proto.schema.FieldState state = 9;
inline void FieldSchema::clear_state() {
  _impl_.state_ = 0;
}
inline ::milvus::proto::schema::FieldState FieldSchema::_internal_state() const {
  return static_cast< ::milvus::proto::schema::FieldState >(_impl_.state_);
}
inline ::milvus::proto::schema::FieldState FieldSchema::state() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldSchema.state)
  return _internal_state();
}
inline void FieldSchema::_internal_set_state(::milvus::proto::schema::FieldState value) {
  
  _impl_.state_ = value;
}
inline void FieldSchema::set_state(::milvus::proto::schema::FieldState value) {
  _internal_set_state(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldSchema.state)
}

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

// CollectionSchema

// string name = 1;
inline void CollectionSchema::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& CollectionSchema::name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.CollectionSchema.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CollectionSchema::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.schema.CollectionSchema.name)
}
inline std::string* CollectionSchema::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.CollectionSchema.name)
  return _s;
}
inline const std::string& CollectionSchema::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CollectionSchema::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CollectionSchema::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CollectionSchema::release_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.CollectionSchema.name)
  return _impl_.name_.Release();
}
inline void CollectionSchema::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.CollectionSchema.name)
}

// string description = 2;
inline void CollectionSchema::clear_description() {
  _impl_.description_.ClearToEmpty();
}
inline const std::string& CollectionSchema::description() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.CollectionSchema.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CollectionSchema::set_description(ArgT0&& arg0, ArgT... args) {
 
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.schema.CollectionSchema.description)
}
inline std::string* CollectionSchema::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.CollectionSchema.description)
  return _s;
}
inline const std::string& CollectionSchema::_internal_description() const {
  return _impl_.description_.Get();
}
inline void CollectionSchema::_internal_set_description(const std::string& value) {
  
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* CollectionSchema::_internal_mutable_description() {
  
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* CollectionSchema::release_description() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.CollectionSchema.description)
  return _impl_.description_.Release();
}
inline void CollectionSchema::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.CollectionSchema.description)
}

// bool autoID = 3;
inline void CollectionSchema::clear_autoid() {
  _impl_.autoid_ = false;
}
inline bool CollectionSchema::_internal_autoid() const {
  return _impl_.autoid_;
}
inline bool CollectionSchema::autoid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.CollectionSchema.autoID)
  return _internal_autoid();
}
inline void CollectionSchema::_internal_set_autoid(bool value) {
  
  _impl_.autoid_ = value;
}
inline void CollectionSchema::set_autoid(bool value) {
  _internal_set_autoid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.CollectionSchema.autoID)
}

// repeated .milvus.proto.schema.FieldSchema fields = 4;
inline int CollectionSchema::_internal_fields_size() const {
  return _impl_.fields_.size();
}
inline int CollectionSchema::fields_size() const {
  return _internal_fields_size();
}
inline void CollectionSchema::clear_fields() {
  _impl_.fields_.Clear();
}
inline ::milvus::proto::schema::FieldSchema* CollectionSchema::mutable_fields(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.CollectionSchema.fields)
  return _impl_.fields_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldSchema >*
CollectionSchema::mutable_fields() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.CollectionSchema.fields)
  return &_impl_.fields_;
}
inline const ::milvus::proto::schema::FieldSchema& CollectionSchema::_internal_fields(int index) const {
  return _impl_.fields_.Get(index);
}
inline const ::milvus::proto::schema::FieldSchema& CollectionSchema::fields(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.CollectionSchema.fields)
  return _internal_fields(index);
}
inline ::milvus::proto::schema::FieldSchema* CollectionSchema::_internal_add_fields() {
  return _impl_.fields_.Add();
}
inline ::milvus::proto::schema::FieldSchema* CollectionSchema::add_fields() {
  ::milvus::proto::schema::FieldSchema* _add = _internal_add_fields();
  // @@protoc_insertion_point(field_add:milvus.proto.schema.CollectionSchema.fields)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldSchema >&
CollectionSchema::fields() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.CollectionSchema.fields)
  return _impl_.fields_;
}

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

// BoolArray

// repeated bool data = 1;
inline int BoolArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int BoolArray::data_size() const {
  return _internal_data_size();
}
inline void BoolArray::clear_data() {
  _impl_.data_.Clear();
}
inline bool BoolArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline bool BoolArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.BoolArray.data)
  return _internal_data(index);
}
inline void BoolArray::set_data(int index, bool value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.BoolArray.data)
}
inline void BoolArray::_internal_add_data(bool value) {
  _impl_.data_.Add(value);
}
inline void BoolArray::add_data(bool value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.BoolArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
BoolArray::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
BoolArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.BoolArray.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
BoolArray::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
BoolArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.BoolArray.data)
  return _internal_mutable_data();
}

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

// IntArray

// repeated int32 data = 1;
inline int IntArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int IntArray::data_size() const {
  return _internal_data_size();
}
inline void IntArray::clear_data() {
  _impl_.data_.Clear();
}
inline int32_t IntArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline int32_t IntArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.IntArray.data)
  return _internal_data(index);
}
inline void IntArray::set_data(int index, int32_t value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.IntArray.data)
}
inline void IntArray::_internal_add_data(int32_t value) {
  _impl_.data_.Add(value);
}
inline void IntArray::add_data(int32_t value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.IntArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
IntArray::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
IntArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.IntArray.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
IntArray::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
IntArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.IntArray.data)
  return _internal_mutable_data();
}

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

// LongArray

// repeated int64 data = 1;
inline int LongArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int LongArray::data_size() const {
  return _internal_data_size();
}
inline void LongArray::clear_data() {
  _impl_.data_.Clear();
}
inline int64_t LongArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline int64_t LongArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.LongArray.data)
  return _internal_data(index);
}
inline void LongArray::set_data(int index, int64_t value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.LongArray.data)
}
inline void LongArray::_internal_add_data(int64_t value) {
  _impl_.data_.Add(value);
}
inline void LongArray::add_data(int64_t value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.LongArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
LongArray::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
LongArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.LongArray.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
LongArray::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
LongArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.LongArray.data)
  return _internal_mutable_data();
}

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

// FloatArray

// repeated float data = 1;
inline int FloatArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int FloatArray::data_size() const {
  return _internal_data_size();
}
inline void FloatArray::clear_data() {
  _impl_.data_.Clear();
}
inline float FloatArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline float FloatArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FloatArray.data)
  return _internal_data(index);
}
inline void FloatArray::set_data(int index, float value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FloatArray.data)
}
inline void FloatArray::_internal_add_data(float value) {
  _impl_.data_.Add(value);
}
inline void FloatArray::add_data(float value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.FloatArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
FloatArray::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
FloatArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.FloatArray.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
FloatArray::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
FloatArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.FloatArray.data)
  return _internal_mutable_data();
}

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

// DoubleArray

// repeated double data = 1;
inline int DoubleArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int DoubleArray::data_size() const {
  return _internal_data_size();
}
inline void DoubleArray::clear_data() {
  _impl_.data_.Clear();
}
inline double DoubleArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline double DoubleArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.DoubleArray.data)
  return _internal_data(index);
}
inline void DoubleArray::set_data(int index, double value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.DoubleArray.data)
}
inline void DoubleArray::_internal_add_data(double value) {
  _impl_.data_.Add(value);
}
inline void DoubleArray::add_data(double value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.DoubleArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DoubleArray::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DoubleArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.DoubleArray.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DoubleArray::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DoubleArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.DoubleArray.data)
  return _internal_mutable_data();
}

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

// BytesArray

// repeated bytes data = 1;
inline int BytesArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int BytesArray::data_size() const {
  return _internal_data_size();
}
inline void BytesArray::clear_data() {
  _impl_.data_.Clear();
}
inline std::string* BytesArray::add_data() {
  std::string* _s = _internal_add_data();
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.schema.BytesArray.data)
  return _s;
}
inline const std::string& BytesArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline const std::string& BytesArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.BytesArray.data)
  return _internal_data(index);
}
inline std::string* BytesArray::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.BytesArray.data)
  return _impl_.data_.Mutable(index);
}
inline void BytesArray::set_data(int index, const std::string& value) {
  _impl_.data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.BytesArray.data)
}
inline void BytesArray::set_data(int index, std::string&& value) {
  _impl_.data_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:milvus.proto.schema.BytesArray.data)
}
inline void BytesArray::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.schema.BytesArray.data)
}
inline void BytesArray::set_data(int index, const void* value, size_t size) {
  _impl_.data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.schema.BytesArray.data)
}
inline std::string* BytesArray::_internal_add_data() {
  return _impl_.data_.Add();
}
inline void BytesArray::add_data(const std::string& value) {
  _impl_.data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.BytesArray.data)
}
inline void BytesArray::add_data(std::string&& value) {
  _impl_.data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.schema.BytesArray.data)
}
inline void BytesArray::add_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.schema.BytesArray.data)
}
inline void BytesArray::add_data(const void* value, size_t size) {
  _impl_.data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.schema.BytesArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BytesArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.BytesArray.data)
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BytesArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.BytesArray.data)
  return &_impl_.data_;
}

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

// StringArray

// repeated string data = 1;
inline int StringArray::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int StringArray::data_size() const {
  return _internal_data_size();
}
inline void StringArray::clear_data() {
  _impl_.data_.Clear();
}
inline std::string* StringArray::add_data() {
  std::string* _s = _internal_add_data();
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.schema.StringArray.data)
  return _s;
}
inline const std::string& StringArray::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline const std::string& StringArray::data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.StringArray.data)
  return _internal_data(index);
}
inline std::string* StringArray::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.StringArray.data)
  return _impl_.data_.Mutable(index);
}
inline void StringArray::set_data(int index, const std::string& value) {
  _impl_.data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.StringArray.data)
}
inline void StringArray::set_data(int index, std::string&& value) {
  _impl_.data_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:milvus.proto.schema.StringArray.data)
}
inline void StringArray::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.schema.StringArray.data)
}
inline void StringArray::set_data(int index, const char* value, size_t size) {
  _impl_.data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.schema.StringArray.data)
}
inline std::string* StringArray::_internal_add_data() {
  return _impl_.data_.Add();
}
inline void StringArray::add_data(const std::string& value) {
  _impl_.data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.StringArray.data)
}
inline void StringArray::add_data(std::string&& value) {
  _impl_.data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.schema.StringArray.data)
}
inline void StringArray::add_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.schema.StringArray.data)
}
inline void StringArray::add_data(const char* value, size_t size) {
  _impl_.data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.schema.StringArray.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
StringArray::data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.StringArray.data)
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
StringArray::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.StringArray.data)
  return &_impl_.data_;
}

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

// ScalarField

// .milvus.proto.schema.BoolArray bool_data = 1;
inline bool ScalarField::_internal_has_bool_data() const {
  return data_case() == kBoolData;
}
inline bool ScalarField::has_bool_data() const {
  return _internal_has_bool_data();
}
inline void ScalarField::set_has_bool_data() {
  _impl_._oneof_case_[0] = kBoolData;
}
inline void ScalarField::clear_bool_data() {
  if (_internal_has_bool_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.bool_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::BoolArray* ScalarField::release_bool_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.bool_data)
  if (_internal_has_bool_data()) {
    clear_has_data();
    ::milvus::proto::schema::BoolArray* temp = _impl_.data_.bool_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.bool_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::BoolArray& ScalarField::_internal_bool_data() const {
  return _internal_has_bool_data()
      ? *_impl_.data_.bool_data_
      : reinterpret_cast< ::milvus::proto::schema::BoolArray&>(::milvus::proto::schema::_BoolArray_default_instance_);
}
inline const ::milvus::proto::schema::BoolArray& ScalarField::bool_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.bool_data)
  return _internal_bool_data();
}
inline ::milvus::proto::schema::BoolArray* ScalarField::unsafe_arena_release_bool_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.bool_data)
  if (_internal_has_bool_data()) {
    clear_has_data();
    ::milvus::proto::schema::BoolArray* temp = _impl_.data_.bool_data_;
    _impl_.data_.bool_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_bool_data(::milvus::proto::schema::BoolArray* bool_data) {
  clear_data();
  if (bool_data) {
    set_has_bool_data();
    _impl_.data_.bool_data_ = bool_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.bool_data)
}
inline ::milvus::proto::schema::BoolArray* ScalarField::_internal_mutable_bool_data() {
  if (!_internal_has_bool_data()) {
    clear_data();
    set_has_bool_data();
    _impl_.data_.bool_data_ = CreateMaybeMessage< ::milvus::proto::schema::BoolArray >(GetArenaForAllocation());
  }
  return _impl_.data_.bool_data_;
}
inline ::milvus::proto::schema::BoolArray* ScalarField::mutable_bool_data() {
  ::milvus::proto::schema::BoolArray* _msg = _internal_mutable_bool_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.bool_data)
  return _msg;
}

// .milvus.proto.schema.IntArray int_data = 2;
inline bool ScalarField::_internal_has_int_data() const {
  return data_case() == kIntData;
}
inline bool ScalarField::has_int_data() const {
  return _internal_has_int_data();
}
inline void ScalarField::set_has_int_data() {
  _impl_._oneof_case_[0] = kIntData;
}
inline void ScalarField::clear_int_data() {
  if (_internal_has_int_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.int_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::IntArray* ScalarField::release_int_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.int_data)
  if (_internal_has_int_data()) {
    clear_has_data();
    ::milvus::proto::schema::IntArray* temp = _impl_.data_.int_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.int_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::IntArray& ScalarField::_internal_int_data() const {
  return _internal_has_int_data()
      ? *_impl_.data_.int_data_
      : reinterpret_cast< ::milvus::proto::schema::IntArray&>(::milvus::proto::schema::_IntArray_default_instance_);
}
inline const ::milvus::proto::schema::IntArray& ScalarField::int_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.int_data)
  return _internal_int_data();
}
inline ::milvus::proto::schema::IntArray* ScalarField::unsafe_arena_release_int_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.int_data)
  if (_internal_has_int_data()) {
    clear_has_data();
    ::milvus::proto::schema::IntArray* temp = _impl_.data_.int_data_;
    _impl_.data_.int_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_int_data(::milvus::proto::schema::IntArray* int_data) {
  clear_data();
  if (int_data) {
    set_has_int_data();
    _impl_.data_.int_data_ = int_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.int_data)
}
inline ::milvus::proto::schema::IntArray* ScalarField::_internal_mutable_int_data() {
  if (!_internal_has_int_data()) {
    clear_data();
    set_has_int_data();
    _impl_.data_.int_data_ = CreateMaybeMessage< ::milvus::proto::schema::IntArray >(GetArenaForAllocation());
  }
  return _impl_.data_.int_data_;
}
inline ::milvus::proto::schema::IntArray* ScalarField::mutable_int_data() {
  ::milvus::proto::schema::IntArray* _msg = _internal_mutable_int_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.int_data)
  return _msg;
}

// .milvus.proto.schema.LongArray long_data = 3;
inline bool ScalarField::_internal_has_long_data() const {
  return data_case() == kLongData;
}
inline bool ScalarField::has_long_data() const {
  return _internal_has_long_data();
}
inline void ScalarField::set_has_long_data() {
  _impl_._oneof_case_[0] = kLongData;
}
inline void ScalarField::clear_long_data() {
  if (_internal_has_long_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.long_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::LongArray* ScalarField::release_long_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.long_data)
  if (_internal_has_long_data()) {
    clear_has_data();
    ::milvus::proto::schema::LongArray* temp = _impl_.data_.long_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.long_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::LongArray& ScalarField::_internal_long_data() const {
  return _internal_has_long_data()
      ? *_impl_.data_.long_data_
      : reinterpret_cast< ::milvus::proto::schema::LongArray&>(::milvus::proto::schema::_LongArray_default_instance_);
}
inline const ::milvus::proto::schema::LongArray& ScalarField::long_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.long_data)
  return _internal_long_data();
}
inline ::milvus::proto::schema::LongArray* ScalarField::unsafe_arena_release_long_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.long_data)
  if (_internal_has_long_data()) {
    clear_has_data();
    ::milvus::proto::schema::LongArray* temp = _impl_.data_.long_data_;
    _impl_.data_.long_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_long_data(::milvus::proto::schema::LongArray* long_data) {
  clear_data();
  if (long_data) {
    set_has_long_data();
    _impl_.data_.long_data_ = long_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.long_data)
}
inline ::milvus::proto::schema::LongArray* ScalarField::_internal_mutable_long_data() {
  if (!_internal_has_long_data()) {
    clear_data();
    set_has_long_data();
    _impl_.data_.long_data_ = CreateMaybeMessage< ::milvus::proto::schema::LongArray >(GetArenaForAllocation());
  }
  return _impl_.data_.long_data_;
}
inline ::milvus::proto::schema::LongArray* ScalarField::mutable_long_data() {
  ::milvus::proto::schema::LongArray* _msg = _internal_mutable_long_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.long_data)
  return _msg;
}

// .milvus.proto.schema.FloatArray float_data = 4;
inline bool ScalarField::_internal_has_float_data() const {
  return data_case() == kFloatData;
}
inline bool ScalarField::has_float_data() const {
  return _internal_has_float_data();
}
inline void ScalarField::set_has_float_data() {
  _impl_._oneof_case_[0] = kFloatData;
}
inline void ScalarField::clear_float_data() {
  if (_internal_has_float_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.float_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::FloatArray* ScalarField::release_float_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.float_data)
  if (_internal_has_float_data()) {
    clear_has_data();
    ::milvus::proto::schema::FloatArray* temp = _impl_.data_.float_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.float_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::FloatArray& ScalarField::_internal_float_data() const {
  return _internal_has_float_data()
      ? *_impl_.data_.float_data_
      : reinterpret_cast< ::milvus::proto::schema::FloatArray&>(::milvus::proto::schema::_FloatArray_default_instance_);
}
inline const ::milvus::proto::schema::FloatArray& ScalarField::float_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.float_data)
  return _internal_float_data();
}
inline ::milvus::proto::schema::FloatArray* ScalarField::unsafe_arena_release_float_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.float_data)
  if (_internal_has_float_data()) {
    clear_has_data();
    ::milvus::proto::schema::FloatArray* temp = _impl_.data_.float_data_;
    _impl_.data_.float_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_float_data(::milvus::proto::schema::FloatArray* float_data) {
  clear_data();
  if (float_data) {
    set_has_float_data();
    _impl_.data_.float_data_ = float_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.float_data)
}
inline ::milvus::proto::schema::FloatArray* ScalarField::_internal_mutable_float_data() {
  if (!_internal_has_float_data()) {
    clear_data();
    set_has_float_data();
    _impl_.data_.float_data_ = CreateMaybeMessage< ::milvus::proto::schema::FloatArray >(GetArenaForAllocation());
  }
  return _impl_.data_.float_data_;
}
inline ::milvus::proto::schema::FloatArray* ScalarField::mutable_float_data() {
  ::milvus::proto::schema::FloatArray* _msg = _internal_mutable_float_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.float_data)
  return _msg;
}

// .milvus.proto.schema.DoubleArray double_data = 5;
inline bool ScalarField::_internal_has_double_data() const {
  return data_case() == kDoubleData;
}
inline bool ScalarField::has_double_data() const {
  return _internal_has_double_data();
}
inline void ScalarField::set_has_double_data() {
  _impl_._oneof_case_[0] = kDoubleData;
}
inline void ScalarField::clear_double_data() {
  if (_internal_has_double_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.double_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::DoubleArray* ScalarField::release_double_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.double_data)
  if (_internal_has_double_data()) {
    clear_has_data();
    ::milvus::proto::schema::DoubleArray* temp = _impl_.data_.double_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.double_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::DoubleArray& ScalarField::_internal_double_data() const {
  return _internal_has_double_data()
      ? *_impl_.data_.double_data_
      : reinterpret_cast< ::milvus::proto::schema::DoubleArray&>(::milvus::proto::schema::_DoubleArray_default_instance_);
}
inline const ::milvus::proto::schema::DoubleArray& ScalarField::double_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.double_data)
  return _internal_double_data();
}
inline ::milvus::proto::schema::DoubleArray* ScalarField::unsafe_arena_release_double_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.double_data)
  if (_internal_has_double_data()) {
    clear_has_data();
    ::milvus::proto::schema::DoubleArray* temp = _impl_.data_.double_data_;
    _impl_.data_.double_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_double_data(::milvus::proto::schema::DoubleArray* double_data) {
  clear_data();
  if (double_data) {
    set_has_double_data();
    _impl_.data_.double_data_ = double_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.double_data)
}
inline ::milvus::proto::schema::DoubleArray* ScalarField::_internal_mutable_double_data() {
  if (!_internal_has_double_data()) {
    clear_data();
    set_has_double_data();
    _impl_.data_.double_data_ = CreateMaybeMessage< ::milvus::proto::schema::DoubleArray >(GetArenaForAllocation());
  }
  return _impl_.data_.double_data_;
}
inline ::milvus::proto::schema::DoubleArray* ScalarField::mutable_double_data() {
  ::milvus::proto::schema::DoubleArray* _msg = _internal_mutable_double_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.double_data)
  return _msg;
}

// .milvus.proto.schema.StringArray string_data = 6;
inline bool ScalarField::_internal_has_string_data() const {
  return data_case() == kStringData;
}
inline bool ScalarField::has_string_data() const {
  return _internal_has_string_data();
}
inline void ScalarField::set_has_string_data() {
  _impl_._oneof_case_[0] = kStringData;
}
inline void ScalarField::clear_string_data() {
  if (_internal_has_string_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.string_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::StringArray* ScalarField::release_string_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.string_data)
  if (_internal_has_string_data()) {
    clear_has_data();
    ::milvus::proto::schema::StringArray* temp = _impl_.data_.string_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.string_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::StringArray& ScalarField::_internal_string_data() const {
  return _internal_has_string_data()
      ? *_impl_.data_.string_data_
      : reinterpret_cast< ::milvus::proto::schema::StringArray&>(::milvus::proto::schema::_StringArray_default_instance_);
}
inline const ::milvus::proto::schema::StringArray& ScalarField::string_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.string_data)
  return _internal_string_data();
}
inline ::milvus::proto::schema::StringArray* ScalarField::unsafe_arena_release_string_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.string_data)
  if (_internal_has_string_data()) {
    clear_has_data();
    ::milvus::proto::schema::StringArray* temp = _impl_.data_.string_data_;
    _impl_.data_.string_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_string_data(::milvus::proto::schema::StringArray* string_data) {
  clear_data();
  if (string_data) {
    set_has_string_data();
    _impl_.data_.string_data_ = string_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.string_data)
}
inline ::milvus::proto::schema::StringArray* ScalarField::_internal_mutable_string_data() {
  if (!_internal_has_string_data()) {
    clear_data();
    set_has_string_data();
    _impl_.data_.string_data_ = CreateMaybeMessage< ::milvus::proto::schema::StringArray >(GetArenaForAllocation());
  }
  return _impl_.data_.string_data_;
}
inline ::milvus::proto::schema::StringArray* ScalarField::mutable_string_data() {
  ::milvus::proto::schema::StringArray* _msg = _internal_mutable_string_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.string_data)
  return _msg;
}

// .milvus.proto.schema.BytesArray bytes_data = 7;
inline bool ScalarField::_internal_has_bytes_data() const {
  return data_case() == kBytesData;
}
inline bool ScalarField::has_bytes_data() const {
  return _internal_has_bytes_data();
}
inline void ScalarField::set_has_bytes_data() {
  _impl_._oneof_case_[0] = kBytesData;
}
inline void ScalarField::clear_bytes_data() {
  if (_internal_has_bytes_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.bytes_data_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::BytesArray* ScalarField::release_bytes_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.ScalarField.bytes_data)
  if (_internal_has_bytes_data()) {
    clear_has_data();
    ::milvus::proto::schema::BytesArray* temp = _impl_.data_.bytes_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.bytes_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::BytesArray& ScalarField::_internal_bytes_data() const {
  return _internal_has_bytes_data()
      ? *_impl_.data_.bytes_data_
      : reinterpret_cast< ::milvus::proto::schema::BytesArray&>(::milvus::proto::schema::_BytesArray_default_instance_);
}
inline const ::milvus::proto::schema::BytesArray& ScalarField::bytes_data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.ScalarField.bytes_data)
  return _internal_bytes_data();
}
inline ::milvus::proto::schema::BytesArray* ScalarField::unsafe_arena_release_bytes_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.ScalarField.bytes_data)
  if (_internal_has_bytes_data()) {
    clear_has_data();
    ::milvus::proto::schema::BytesArray* temp = _impl_.data_.bytes_data_;
    _impl_.data_.bytes_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ScalarField::unsafe_arena_set_allocated_bytes_data(::milvus::proto::schema::BytesArray* bytes_data) {
  clear_data();
  if (bytes_data) {
    set_has_bytes_data();
    _impl_.data_.bytes_data_ = bytes_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.ScalarField.bytes_data)
}
inline ::milvus::proto::schema::BytesArray* ScalarField::_internal_mutable_bytes_data() {
  if (!_internal_has_bytes_data()) {
    clear_data();
    set_has_bytes_data();
    _impl_.data_.bytes_data_ = CreateMaybeMessage< ::milvus::proto::schema::BytesArray >(GetArenaForAllocation());
  }
  return _impl_.data_.bytes_data_;
}
inline ::milvus::proto::schema::BytesArray* ScalarField::mutable_bytes_data() {
  ::milvus::proto::schema::BytesArray* _msg = _internal_mutable_bytes_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.ScalarField.bytes_data)
  return _msg;
}

inline bool ScalarField::has_data() const {
  return data_case() != DATA_NOT_SET;
}
inline void ScalarField::clear_has_data() {
  _impl_._oneof_case_[0] = DATA_NOT_SET;
}
inline ScalarField::DataCase ScalarField::data_case() const {
  return ScalarField::DataCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// VectorField

// int64 dim = 1;
inline void VectorField::clear_dim() {
  _impl_.dim_ = int64_t{0};
}
inline int64_t VectorField::_internal_dim() const {
  return _impl_.dim_;
}
inline int64_t VectorField::dim() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.VectorField.dim)
  return _internal_dim();
}
inline void VectorField::_internal_set_dim(int64_t value) {
  
  _impl_.dim_ = value;
}
inline void VectorField::set_dim(int64_t value) {
  _internal_set_dim(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.VectorField.dim)
}

// .milvus.proto.schema.FloatArray float_vector = 2;
inline bool VectorField::_internal_has_float_vector() const {
  return data_case() == kFloatVector;
}
inline bool VectorField::has_float_vector() const {
  return _internal_has_float_vector();
}
inline void VectorField::set_has_float_vector() {
  _impl_._oneof_case_[0] = kFloatVector;
}
inline void VectorField::clear_float_vector() {
  if (_internal_has_float_vector()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.data_.float_vector_;
    }
    clear_has_data();
  }
}
inline ::milvus::proto::schema::FloatArray* VectorField::release_float_vector() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.VectorField.float_vector)
  if (_internal_has_float_vector()) {
    clear_has_data();
    ::milvus::proto::schema::FloatArray* temp = _impl_.data_.float_vector_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.data_.float_vector_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::FloatArray& VectorField::_internal_float_vector() const {
  return _internal_has_float_vector()
      ? *_impl_.data_.float_vector_
      : reinterpret_cast< ::milvus::proto::schema::FloatArray&>(::milvus::proto::schema::_FloatArray_default_instance_);
}
inline const ::milvus::proto::schema::FloatArray& VectorField::float_vector() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.VectorField.float_vector)
  return _internal_float_vector();
}
inline ::milvus::proto::schema::FloatArray* VectorField::unsafe_arena_release_float_vector() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.VectorField.float_vector)
  if (_internal_has_float_vector()) {
    clear_has_data();
    ::milvus::proto::schema::FloatArray* temp = _impl_.data_.float_vector_;
    _impl_.data_.float_vector_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void VectorField::unsafe_arena_set_allocated_float_vector(::milvus::proto::schema::FloatArray* float_vector) {
  clear_data();
  if (float_vector) {
    set_has_float_vector();
    _impl_.data_.float_vector_ = float_vector;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.VectorField.float_vector)
}
inline ::milvus::proto::schema::FloatArray* VectorField::_internal_mutable_float_vector() {
  if (!_internal_has_float_vector()) {
    clear_data();
    set_has_float_vector();
    _impl_.data_.float_vector_ = CreateMaybeMessage< ::milvus::proto::schema::FloatArray >(GetArenaForAllocation());
  }
  return _impl_.data_.float_vector_;
}
inline ::milvus::proto::schema::FloatArray* VectorField::mutable_float_vector() {
  ::milvus::proto::schema::FloatArray* _msg = _internal_mutable_float_vector();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.VectorField.float_vector)
  return _msg;
}

// bytes binary_vector = 3;
inline bool VectorField::_internal_has_binary_vector() const {
  return data_case() == kBinaryVector;
}
inline bool VectorField::has_binary_vector() const {
  return _internal_has_binary_vector();
}
inline void VectorField::set_has_binary_vector() {
  _impl_._oneof_case_[0] = kBinaryVector;
}
inline void VectorField::clear_binary_vector() {
  if (_internal_has_binary_vector()) {
    _impl_.data_.binary_vector_.Destroy();
    clear_has_data();
  }
}
inline const std::string& VectorField::binary_vector() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.VectorField.binary_vector)
  return _internal_binary_vector();
}
template <typename ArgT0, typename... ArgT>
inline void VectorField::set_binary_vector(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_binary_vector()) {
    clear_data();
    set_has_binary_vector();
    _impl_.data_.binary_vector_.InitDefault();
  }
  _impl_.data_.binary_vector_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.schema.VectorField.binary_vector)
}
inline std::string* VectorField::mutable_binary_vector() {
  std::string* _s = _internal_mutable_binary_vector();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.VectorField.binary_vector)
  return _s;
}
inline const std::string& VectorField::_internal_binary_vector() const {
  if (_internal_has_binary_vector()) {
    return _impl_.data_.binary_vector_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void VectorField::_internal_set_binary_vector(const std::string& value) {
  if (!_internal_has_binary_vector()) {
    clear_data();
    set_has_binary_vector();
    _impl_.data_.binary_vector_.InitDefault();
  }
  _impl_.data_.binary_vector_.Set(value, GetArenaForAllocation());
}
inline std::string* VectorField::_internal_mutable_binary_vector() {
  if (!_internal_has_binary_vector()) {
    clear_data();
    set_has_binary_vector();
    _impl_.data_.binary_vector_.InitDefault();
  }
  return _impl_.data_.binary_vector_.Mutable(      GetArenaForAllocation());
}
inline std::string* VectorField::release_binary_vector() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.VectorField.binary_vector)
  if (_internal_has_binary_vector()) {
    clear_has_data();
    return _impl_.data_.binary_vector_.Release();
  } else {
    return nullptr;
  }
}
inline void VectorField::set_allocated_binary_vector(std::string* binary_vector) {
  if (has_data()) {
    clear_data();
  }
  if (binary_vector != nullptr) {
    set_has_binary_vector();
    _impl_.data_.binary_vector_.InitAllocated(binary_vector, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.VectorField.binary_vector)
}

inline bool VectorField::has_data() const {
  return data_case() != DATA_NOT_SET;
}
inline void VectorField::clear_has_data() {
  _impl_._oneof_case_[0] = DATA_NOT_SET;
}
inline VectorField::DataCase VectorField::data_case() const {
  return VectorField::DataCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// FieldData

// .milvus.proto.schema.DataType type = 1;
inline void FieldData::clear_type() {
  _impl_.type_ = 0;
}
inline ::milvus::proto::schema::DataType FieldData::_internal_type() const {
  return static_cast< ::milvus::proto::schema::DataType >(_impl_.type_);
}
inline ::milvus::proto::schema::DataType FieldData::type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldData.type)
  return _internal_type();
}
inline void FieldData::_internal_set_type(::milvus::proto::schema::DataType value) {
  
  _impl_.type_ = value;
}
inline void FieldData::set_type(::milvus::proto::schema::DataType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldData.type)
}

// string field_name = 2;
inline void FieldData::clear_field_name() {
  _impl_.field_name_.ClearToEmpty();
}
inline const std::string& FieldData::field_name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldData.field_name)
  return _internal_field_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldData::set_field_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.field_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldData.field_name)
}
inline std::string* FieldData::mutable_field_name() {
  std::string* _s = _internal_mutable_field_name();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldData.field_name)
  return _s;
}
inline const std::string& FieldData::_internal_field_name() const {
  return _impl_.field_name_.Get();
}
inline void FieldData::_internal_set_field_name(const std::string& value) {
  
  _impl_.field_name_.Set(value, GetArenaForAllocation());
}
inline std::string* FieldData::_internal_mutable_field_name() {
  
  return _impl_.field_name_.Mutable(GetArenaForAllocation());
}
inline std::string* FieldData::release_field_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.FieldData.field_name)
  return _impl_.field_name_.Release();
}
inline void FieldData::set_allocated_field_name(std::string* field_name) {
  if (field_name != nullptr) {
    
  } else {
    
  }
  _impl_.field_name_.SetAllocated(field_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.field_name_.IsDefault()) {
    _impl_.field_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.FieldData.field_name)
}

// .milvus.proto.schema.ScalarField scalars = 3;
inline bool FieldData::_internal_has_scalars() const {
  return field_case() == kScalars;
}
inline bool FieldData::has_scalars() const {
  return _internal_has_scalars();
}
inline void FieldData::set_has_scalars() {
  _impl_._oneof_case_[0] = kScalars;
}
inline void FieldData::clear_scalars() {
  if (_internal_has_scalars()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.field_.scalars_;
    }
    clear_has_field();
  }
}
inline ::milvus::proto::schema::ScalarField* FieldData::release_scalars() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.FieldData.scalars)
  if (_internal_has_scalars()) {
    clear_has_field();
    ::milvus::proto::schema::ScalarField* temp = _impl_.field_.scalars_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.field_.scalars_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::ScalarField& FieldData::_internal_scalars() const {
  return _internal_has_scalars()
      ? *_impl_.field_.scalars_
      : reinterpret_cast< ::milvus::proto::schema::ScalarField&>(::milvus::proto::schema::_ScalarField_default_instance_);
}
inline const ::milvus::proto::schema::ScalarField& FieldData::scalars() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldData.scalars)
  return _internal_scalars();
}
inline ::milvus::proto::schema::ScalarField* FieldData::unsafe_arena_release_scalars() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.FieldData.scalars)
  if (_internal_has_scalars()) {
    clear_has_field();
    ::milvus::proto::schema::ScalarField* temp = _impl_.field_.scalars_;
    _impl_.field_.scalars_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FieldData::unsafe_arena_set_allocated_scalars(::milvus::proto::schema::ScalarField* scalars) {
  clear_field();
  if (scalars) {
    set_has_scalars();
    _impl_.field_.scalars_ = scalars;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.FieldData.scalars)
}
inline ::milvus::proto::schema::ScalarField* FieldData::_internal_mutable_scalars() {
  if (!_internal_has_scalars()) {
    clear_field();
    set_has_scalars();
    _impl_.field_.scalars_ = CreateMaybeMessage< ::milvus::proto::schema::ScalarField >(GetArenaForAllocation());
  }
  return _impl_.field_.scalars_;
}
inline ::milvus::proto::schema::ScalarField* FieldData::mutable_scalars() {
  ::milvus::proto::schema::ScalarField* _msg = _internal_mutable_scalars();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldData.scalars)
  return _msg;
}

// .milvus.proto.schema.VectorField vectors = 4;
inline bool FieldData::_internal_has_vectors() const {
  return field_case() == kVectors;
}
inline bool FieldData::has_vectors() const {
  return _internal_has_vectors();
}
inline void FieldData::set_has_vectors() {
  _impl_._oneof_case_[0] = kVectors;
}
inline void FieldData::clear_vectors() {
  if (_internal_has_vectors()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.field_.vectors_;
    }
    clear_has_field();
  }
}
inline ::milvus::proto::schema::VectorField* FieldData::release_vectors() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.FieldData.vectors)
  if (_internal_has_vectors()) {
    clear_has_field();
    ::milvus::proto::schema::VectorField* temp = _impl_.field_.vectors_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.field_.vectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::VectorField& FieldData::_internal_vectors() const {
  return _internal_has_vectors()
      ? *_impl_.field_.vectors_
      : reinterpret_cast< ::milvus::proto::schema::VectorField&>(::milvus::proto::schema::_VectorField_default_instance_);
}
inline const ::milvus::proto::schema::VectorField& FieldData::vectors() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldData.vectors)
  return _internal_vectors();
}
inline ::milvus::proto::schema::VectorField* FieldData::unsafe_arena_release_vectors() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.FieldData.vectors)
  if (_internal_has_vectors()) {
    clear_has_field();
    ::milvus::proto::schema::VectorField* temp = _impl_.field_.vectors_;
    _impl_.field_.vectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FieldData::unsafe_arena_set_allocated_vectors(::milvus::proto::schema::VectorField* vectors) {
  clear_field();
  if (vectors) {
    set_has_vectors();
    _impl_.field_.vectors_ = vectors;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.FieldData.vectors)
}
inline ::milvus::proto::schema::VectorField* FieldData::_internal_mutable_vectors() {
  if (!_internal_has_vectors()) {
    clear_field();
    set_has_vectors();
    _impl_.field_.vectors_ = CreateMaybeMessage< ::milvus::proto::schema::VectorField >(GetArenaForAllocation());
  }
  return _impl_.field_.vectors_;
}
inline ::milvus::proto::schema::VectorField* FieldData::mutable_vectors() {
  ::milvus::proto::schema::VectorField* _msg = _internal_mutable_vectors();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.FieldData.vectors)
  return _msg;
}

// int64 field_id = 5;
inline void FieldData::clear_field_id() {
  _impl_.field_id_ = int64_t{0};
}
inline int64_t FieldData::_internal_field_id() const {
  return _impl_.field_id_;
}
inline int64_t FieldData::field_id() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.FieldData.field_id)
  return _internal_field_id();
}
inline void FieldData::_internal_set_field_id(int64_t value) {
  
  _impl_.field_id_ = value;
}
inline void FieldData::set_field_id(int64_t value) {
  _internal_set_field_id(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.FieldData.field_id)
}

inline bool FieldData::has_field() const {
  return field_case() != FIELD_NOT_SET;
}
inline void FieldData::clear_has_field() {
  _impl_._oneof_case_[0] = FIELD_NOT_SET;
}
inline FieldData::FieldCase FieldData::field_case() const {
  return FieldData::FieldCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// IDs

// .milvus.proto.schema.LongArray int_id = 1;
inline bool IDs::_internal_has_int_id() const {
  return id_field_case() == kIntId;
}
inline bool IDs::has_int_id() const {
  return _internal_has_int_id();
}
inline void IDs::set_has_int_id() {
  _impl_._oneof_case_[0] = kIntId;
}
inline void IDs::clear_int_id() {
  if (_internal_has_int_id()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.id_field_.int_id_;
    }
    clear_has_id_field();
  }
}
inline ::milvus::proto::schema::LongArray* IDs::release_int_id() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.IDs.int_id)
  if (_internal_has_int_id()) {
    clear_has_id_field();
    ::milvus::proto::schema::LongArray* temp = _impl_.id_field_.int_id_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.id_field_.int_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::LongArray& IDs::_internal_int_id() const {
  return _internal_has_int_id()
      ? *_impl_.id_field_.int_id_
      : reinterpret_cast< ::milvus::proto::schema::LongArray&>(::milvus::proto::schema::_LongArray_default_instance_);
}
inline const ::milvus::proto::schema::LongArray& IDs::int_id() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.IDs.int_id)
  return _internal_int_id();
}
inline ::milvus::proto::schema::LongArray* IDs::unsafe_arena_release_int_id() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.IDs.int_id)
  if (_internal_has_int_id()) {
    clear_has_id_field();
    ::milvus::proto::schema::LongArray* temp = _impl_.id_field_.int_id_;
    _impl_.id_field_.int_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void IDs::unsafe_arena_set_allocated_int_id(::milvus::proto::schema::LongArray* int_id) {
  clear_id_field();
  if (int_id) {
    set_has_int_id();
    _impl_.id_field_.int_id_ = int_id;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.IDs.int_id)
}
inline ::milvus::proto::schema::LongArray* IDs::_internal_mutable_int_id() {
  if (!_internal_has_int_id()) {
    clear_id_field();
    set_has_int_id();
    _impl_.id_field_.int_id_ = CreateMaybeMessage< ::milvus::proto::schema::LongArray >(GetArenaForAllocation());
  }
  return _impl_.id_field_.int_id_;
}
inline ::milvus::proto::schema::LongArray* IDs::mutable_int_id() {
  ::milvus::proto::schema::LongArray* _msg = _internal_mutable_int_id();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.IDs.int_id)
  return _msg;
}

// .milvus.proto.schema.StringArray str_id = 2;
inline bool IDs::_internal_has_str_id() const {
  return id_field_case() == kStrId;
}
inline bool IDs::has_str_id() const {
  return _internal_has_str_id();
}
inline void IDs::set_has_str_id() {
  _impl_._oneof_case_[0] = kStrId;
}
inline void IDs::clear_str_id() {
  if (_internal_has_str_id()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.id_field_.str_id_;
    }
    clear_has_id_field();
  }
}
inline ::milvus::proto::schema::StringArray* IDs::release_str_id() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.IDs.str_id)
  if (_internal_has_str_id()) {
    clear_has_id_field();
    ::milvus::proto::schema::StringArray* temp = _impl_.id_field_.str_id_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.id_field_.str_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::schema::StringArray& IDs::_internal_str_id() const {
  return _internal_has_str_id()
      ? *_impl_.id_field_.str_id_
      : reinterpret_cast< ::milvus::proto::schema::StringArray&>(::milvus::proto::schema::_StringArray_default_instance_);
}
inline const ::milvus::proto::schema::StringArray& IDs::str_id() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.IDs.str_id)
  return _internal_str_id();
}
inline ::milvus::proto::schema::StringArray* IDs::unsafe_arena_release_str_id() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.schema.IDs.str_id)
  if (_internal_has_str_id()) {
    clear_has_id_field();
    ::milvus::proto::schema::StringArray* temp = _impl_.id_field_.str_id_;
    _impl_.id_field_.str_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void IDs::unsafe_arena_set_allocated_str_id(::milvus::proto::schema::StringArray* str_id) {
  clear_id_field();
  if (str_id) {
    set_has_str_id();
    _impl_.id_field_.str_id_ = str_id;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.IDs.str_id)
}
inline ::milvus::proto::schema::StringArray* IDs::_internal_mutable_str_id() {
  if (!_internal_has_str_id()) {
    clear_id_field();
    set_has_str_id();
    _impl_.id_field_.str_id_ = CreateMaybeMessage< ::milvus::proto::schema::StringArray >(GetArenaForAllocation());
  }
  return _impl_.id_field_.str_id_;
}
inline ::milvus::proto::schema::StringArray* IDs::mutable_str_id() {
  ::milvus::proto::schema::StringArray* _msg = _internal_mutable_str_id();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.IDs.str_id)
  return _msg;
}

inline bool IDs::has_id_field() const {
  return id_field_case() != ID_FIELD_NOT_SET;
}
inline void IDs::clear_has_id_field() {
  _impl_._oneof_case_[0] = ID_FIELD_NOT_SET;
}
inline IDs::IdFieldCase IDs::id_field_case() const {
  return IDs::IdFieldCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// SearchResultData

// int64 num_queries = 1;
inline void SearchResultData::clear_num_queries() {
  _impl_.num_queries_ = int64_t{0};
}
inline int64_t SearchResultData::_internal_num_queries() const {
  return _impl_.num_queries_;
}
inline int64_t SearchResultData::num_queries() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.SearchResultData.num_queries)
  return _internal_num_queries();
}
inline void SearchResultData::_internal_set_num_queries(int64_t value) {
  
  _impl_.num_queries_ = value;
}
inline void SearchResultData::set_num_queries(int64_t value) {
  _internal_set_num_queries(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.SearchResultData.num_queries)
}

// int64 top_k = 2;
inline void SearchResultData::clear_top_k() {
  _impl_.top_k_ = int64_t{0};
}
inline int64_t SearchResultData::_internal_top_k() const {
  return _impl_.top_k_;
}
inline int64_t SearchResultData::top_k() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.SearchResultData.top_k)
  return _internal_top_k();
}
inline void SearchResultData::_internal_set_top_k(int64_t value) {
  
  _impl_.top_k_ = value;
}
inline void SearchResultData::set_top_k(int64_t value) {
  _internal_set_top_k(value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.SearchResultData.top_k)
}

// repeated .milvus.proto.schema.FieldData fields_data = 3;
inline int SearchResultData::_internal_fields_data_size() const {
  return _impl_.fields_data_.size();
}
inline int SearchResultData::fields_data_size() const {
  return _internal_fields_data_size();
}
inline void SearchResultData::clear_fields_data() {
  _impl_.fields_data_.Clear();
}
inline ::milvus::proto::schema::FieldData* SearchResultData::mutable_fields_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.SearchResultData.fields_data)
  return _impl_.fields_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >*
SearchResultData::mutable_fields_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.SearchResultData.fields_data)
  return &_impl_.fields_data_;
}
inline const ::milvus::proto::schema::FieldData& SearchResultData::_internal_fields_data(int index) const {
  return _impl_.fields_data_.Get(index);
}
inline const ::milvus::proto::schema::FieldData& SearchResultData::fields_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.SearchResultData.fields_data)
  return _internal_fields_data(index);
}
inline ::milvus::proto::schema::FieldData* SearchResultData::_internal_add_fields_data() {
  return _impl_.fields_data_.Add();
}
inline ::milvus::proto::schema::FieldData* SearchResultData::add_fields_data() {
  ::milvus::proto::schema::FieldData* _add = _internal_add_fields_data();
  // @@protoc_insertion_point(field_add:milvus.proto.schema.SearchResultData.fields_data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >&
SearchResultData::fields_data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.SearchResultData.fields_data)
  return _impl_.fields_data_;
}

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

// .milvus.proto.schema.IDs ids = 5;
inline bool SearchResultData::_internal_has_ids() const {
  return this != internal_default_instance() && _impl_.ids_ != nullptr;
}
inline bool SearchResultData::has_ids() const {
  return _internal_has_ids();
}
inline void SearchResultData::clear_ids() {
  if (GetArenaForAllocation() == nullptr && _impl_.ids_ != nullptr) {
    delete _impl_.ids_;
  }
  _impl_.ids_ = nullptr;
}
inline const ::milvus::proto::schema::IDs& SearchResultData::_internal_ids() const {
  const ::milvus::proto::schema::IDs* p = _impl_.ids_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::schema::IDs&>(
      ::milvus::proto::schema::_IDs_default_instance_);
}
inline const ::milvus::proto::schema::IDs& SearchResultData::ids() const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.SearchResultData.ids)
  return _internal_ids();
}
inline void SearchResultData::unsafe_arena_set_allocated_ids(
    ::milvus::proto::schema::IDs* ids) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ids_);
  }
  _impl_.ids_ = ids;
  if (ids) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.schema.SearchResultData.ids)
}
inline ::milvus::proto::schema::IDs* SearchResultData::release_ids() {
  
  ::milvus::proto::schema::IDs* temp = _impl_.ids_;
  _impl_.ids_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::milvus::proto::schema::IDs* SearchResultData::unsafe_arena_release_ids() {
  // @@protoc_insertion_point(field_release:milvus.proto.schema.SearchResultData.ids)
  
  ::milvus::proto::schema::IDs* temp = _impl_.ids_;
  _impl_.ids_ = nullptr;
  return temp;
}
inline ::milvus::proto::schema::IDs* SearchResultData::_internal_mutable_ids() {
  
  if (_impl_.ids_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::schema::IDs>(GetArenaForAllocation());
    _impl_.ids_ = p;
  }
  return _impl_.ids_;
}
inline ::milvus::proto::schema::IDs* SearchResultData::mutable_ids() {
  ::milvus::proto::schema::IDs* _msg = _internal_mutable_ids();
  // @@protoc_insertion_point(field_mutable:milvus.proto.schema.SearchResultData.ids)
  return _msg;
}
inline void SearchResultData::set_allocated_ids(::milvus::proto::schema::IDs* ids) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ids_;
  }
  if (ids) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ids);
    if (message_arena != submessage_arena) {
      ids = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ids, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.ids_ = ids;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.schema.SearchResultData.ids)
}

// repeated int64 topks = 6;
inline int SearchResultData::_internal_topks_size() const {
  return _impl_.topks_.size();
}
inline int SearchResultData::topks_size() const {
  return _internal_topks_size();
}
inline void SearchResultData::clear_topks() {
  _impl_.topks_.Clear();
}
inline int64_t SearchResultData::_internal_topks(int index) const {
  return _impl_.topks_.Get(index);
}
inline int64_t SearchResultData::topks(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.schema.SearchResultData.topks)
  return _internal_topks(index);
}
inline void SearchResultData::set_topks(int index, int64_t value) {
  _impl_.topks_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.schema.SearchResultData.topks)
}
inline void SearchResultData::_internal_add_topks(int64_t value) {
  _impl_.topks_.Add(value);
}
inline void SearchResultData::add_topks(int64_t value) {
  _internal_add_topks(value);
  // @@protoc_insertion_point(field_add:milvus.proto.schema.SearchResultData.topks)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
SearchResultData::_internal_topks() const {
  return _impl_.topks_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
SearchResultData::topks() const {
  // @@protoc_insertion_point(field_list:milvus.proto.schema.SearchResultData.topks)
  return _internal_topks();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
SearchResultData::_internal_mutable_topks() {
  return &_impl_.topks_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
SearchResultData::mutable_topks() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.schema.SearchResultData.topks)
  return _internal_mutable_topks();
}

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace schema
}  // namespace proto
}  // namespace milvus

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::milvus::proto::schema::DataType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::schema::DataType>() {
  return ::milvus::proto::schema::DataType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::schema::FieldState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::schema::FieldState>() {
  return ::milvus::proto::schema::FieldState_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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