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

#ifndef GOOGLE_PROTOBUF_INCLUDED_plan_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_plan_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 "schema.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_plan_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_plan_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto;
namespace milvus {
namespace proto {
namespace plan {
class BinaryArithExpr;
struct BinaryArithExprDefaultTypeInternal;
extern BinaryArithExprDefaultTypeInternal _BinaryArithExpr_default_instance_;
class BinaryArithOp;
struct BinaryArithOpDefaultTypeInternal;
extern BinaryArithOpDefaultTypeInternal _BinaryArithOp_default_instance_;
class BinaryArithOpEvalRangeExpr;
struct BinaryArithOpEvalRangeExprDefaultTypeInternal;
extern BinaryArithOpEvalRangeExprDefaultTypeInternal _BinaryArithOpEvalRangeExpr_default_instance_;
class BinaryExpr;
struct BinaryExprDefaultTypeInternal;
extern BinaryExprDefaultTypeInternal _BinaryExpr_default_instance_;
class BinaryRangeExpr;
struct BinaryRangeExprDefaultTypeInternal;
extern BinaryRangeExprDefaultTypeInternal _BinaryRangeExpr_default_instance_;
class ColumnExpr;
struct ColumnExprDefaultTypeInternal;
extern ColumnExprDefaultTypeInternal _ColumnExpr_default_instance_;
class ColumnInfo;
struct ColumnInfoDefaultTypeInternal;
extern ColumnInfoDefaultTypeInternal _ColumnInfo_default_instance_;
class CompareExpr;
struct CompareExprDefaultTypeInternal;
extern CompareExprDefaultTypeInternal _CompareExpr_default_instance_;
class Expr;
struct ExprDefaultTypeInternal;
extern ExprDefaultTypeInternal _Expr_default_instance_;
class GenericValue;
struct GenericValueDefaultTypeInternal;
extern GenericValueDefaultTypeInternal _GenericValue_default_instance_;
class PlanNode;
struct PlanNodeDefaultTypeInternal;
extern PlanNodeDefaultTypeInternal _PlanNode_default_instance_;
class QueryInfo;
struct QueryInfoDefaultTypeInternal;
extern QueryInfoDefaultTypeInternal _QueryInfo_default_instance_;
class QueryPlanNode;
struct QueryPlanNodeDefaultTypeInternal;
extern QueryPlanNodeDefaultTypeInternal _QueryPlanNode_default_instance_;
class TermExpr;
struct TermExprDefaultTypeInternal;
extern TermExprDefaultTypeInternal _TermExpr_default_instance_;
class UnaryExpr;
struct UnaryExprDefaultTypeInternal;
extern UnaryExprDefaultTypeInternal _UnaryExpr_default_instance_;
class UnaryRangeExpr;
struct UnaryRangeExprDefaultTypeInternal;
extern UnaryRangeExprDefaultTypeInternal _UnaryRangeExpr_default_instance_;
class ValueExpr;
struct ValueExprDefaultTypeInternal;
extern ValueExprDefaultTypeInternal _ValueExpr_default_instance_;
class VectorANNS;
struct VectorANNSDefaultTypeInternal;
extern VectorANNSDefaultTypeInternal _VectorANNS_default_instance_;
}  // namespace plan
}  // namespace proto
}  // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::proto::plan::BinaryArithExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryArithExpr>(Arena*);
template<> ::milvus::proto::plan::BinaryArithOp* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryArithOp>(Arena*);
template<> ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryArithOpEvalRangeExpr>(Arena*);
template<> ::milvus::proto::plan::BinaryExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryExpr>(Arena*);
template<> ::milvus::proto::plan::BinaryRangeExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryRangeExpr>(Arena*);
template<> ::milvus::proto::plan::ColumnExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::ColumnExpr>(Arena*);
template<> ::milvus::proto::plan::ColumnInfo* Arena::CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(Arena*);
template<> ::milvus::proto::plan::CompareExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::CompareExpr>(Arena*);
template<> ::milvus::proto::plan::Expr* Arena::CreateMaybeMessage<::milvus::proto::plan::Expr>(Arena*);
template<> ::milvus::proto::plan::GenericValue* Arena::CreateMaybeMessage<::milvus::proto::plan::GenericValue>(Arena*);
template<> ::milvus::proto::plan::PlanNode* Arena::CreateMaybeMessage<::milvus::proto::plan::PlanNode>(Arena*);
template<> ::milvus::proto::plan::QueryInfo* Arena::CreateMaybeMessage<::milvus::proto::plan::QueryInfo>(Arena*);
template<> ::milvus::proto::plan::QueryPlanNode* Arena::CreateMaybeMessage<::milvus::proto::plan::QueryPlanNode>(Arena*);
template<> ::milvus::proto::plan::TermExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::TermExpr>(Arena*);
template<> ::milvus::proto::plan::UnaryExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::UnaryExpr>(Arena*);
template<> ::milvus::proto::plan::UnaryRangeExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::UnaryRangeExpr>(Arena*);
template<> ::milvus::proto::plan::ValueExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::ValueExpr>(Arena*);
template<> ::milvus::proto::plan::VectorANNS* Arena::CreateMaybeMessage<::milvus::proto::plan::VectorANNS>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
namespace proto {
namespace plan {

enum UnaryExpr_UnaryOp : int {
  UnaryExpr_UnaryOp_Invalid = 0,
  UnaryExpr_UnaryOp_Not = 1,
  UnaryExpr_UnaryOp_UnaryExpr_UnaryOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  UnaryExpr_UnaryOp_UnaryExpr_UnaryOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool UnaryExpr_UnaryOp_IsValid(int value);
constexpr UnaryExpr_UnaryOp UnaryExpr_UnaryOp_UnaryOp_MIN = UnaryExpr_UnaryOp_Invalid;
constexpr UnaryExpr_UnaryOp UnaryExpr_UnaryOp_UnaryOp_MAX = UnaryExpr_UnaryOp_Not;
constexpr int UnaryExpr_UnaryOp_UnaryOp_ARRAYSIZE = UnaryExpr_UnaryOp_UnaryOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* UnaryExpr_UnaryOp_descriptor();
template<typename T>
inline const std::string& UnaryExpr_UnaryOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, UnaryExpr_UnaryOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function UnaryExpr_UnaryOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    UnaryExpr_UnaryOp_descriptor(), enum_t_value);
}
inline bool UnaryExpr_UnaryOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UnaryExpr_UnaryOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<UnaryExpr_UnaryOp>(
    UnaryExpr_UnaryOp_descriptor(), name, value);
}
enum BinaryExpr_BinaryOp : int {
  BinaryExpr_BinaryOp_Invalid = 0,
  BinaryExpr_BinaryOp_LogicalAnd = 1,
  BinaryExpr_BinaryOp_LogicalOr = 2,
  BinaryExpr_BinaryOp_BinaryExpr_BinaryOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  BinaryExpr_BinaryOp_BinaryExpr_BinaryOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool BinaryExpr_BinaryOp_IsValid(int value);
constexpr BinaryExpr_BinaryOp BinaryExpr_BinaryOp_BinaryOp_MIN = BinaryExpr_BinaryOp_Invalid;
constexpr BinaryExpr_BinaryOp BinaryExpr_BinaryOp_BinaryOp_MAX = BinaryExpr_BinaryOp_LogicalOr;
constexpr int BinaryExpr_BinaryOp_BinaryOp_ARRAYSIZE = BinaryExpr_BinaryOp_BinaryOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BinaryExpr_BinaryOp_descriptor();
template<typename T>
inline const std::string& BinaryExpr_BinaryOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BinaryExpr_BinaryOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BinaryExpr_BinaryOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BinaryExpr_BinaryOp_descriptor(), enum_t_value);
}
inline bool BinaryExpr_BinaryOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BinaryExpr_BinaryOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BinaryExpr_BinaryOp>(
    BinaryExpr_BinaryOp_descriptor(), name, value);
}
enum OpType : int {
  Invalid = 0,
  GreaterThan = 1,
  GreaterEqual = 2,
  LessThan = 3,
  LessEqual = 4,
  Equal = 5,
  NotEqual = 6,
  PrefixMatch = 7,
  PostfixMatch = 8,
  Match = 9,
  Range = 10,
  In = 11,
  NotIn = 12,
  OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool OpType_IsValid(int value);
constexpr OpType OpType_MIN = Invalid;
constexpr OpType OpType_MAX = NotIn;
constexpr int OpType_ARRAYSIZE = OpType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor();
template<typename T>
inline const std::string& OpType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OpType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OpType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OpType_descriptor(), enum_t_value);
}
inline bool OpType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OpType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OpType>(
    OpType_descriptor(), name, value);
}
enum ArithOpType : int {
  Unknown = 0,
  Add = 1,
  Sub = 2,
  Mul = 3,
  Div = 4,
  Mod = 5,
  ArithOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ArithOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ArithOpType_IsValid(int value);
constexpr ArithOpType ArithOpType_MIN = Unknown;
constexpr ArithOpType ArithOpType_MAX = Mod;
constexpr int ArithOpType_ARRAYSIZE = ArithOpType_MAX + 1;

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

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

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

  inline GenericValue& operator=(const GenericValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline GenericValue& operator=(GenericValue&& 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 GenericValue& default_instance() {
    return *internal_default_instance();
  }
  enum ValCase {
    kBoolVal = 1,
    kInt64Val = 2,
    kFloatVal = 3,
    kStringVal = 4,
    VAL_NOT_SET = 0,
  };

  static inline const GenericValue* internal_default_instance() {
    return reinterpret_cast<const GenericValue*>(
               &_GenericValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(GenericValue& a, GenericValue& b) {
    a.Swap(&b);
  }
  inline void Swap(GenericValue* 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(GenericValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GenericValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GenericValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GenericValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GenericValue& from) {
    GenericValue::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(GenericValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.GenericValue";
  }
  protected:
  explicit GenericValue(::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 {
    kBoolValFieldNumber = 1,
    kInt64ValFieldNumber = 2,
    kFloatValFieldNumber = 3,
    kStringValFieldNumber = 4,
  };
  // bool bool_val = 1;
  bool has_bool_val() const;
  private:
  bool _internal_has_bool_val() const;
  public:
  void clear_bool_val();
  bool bool_val() const;
  void set_bool_val(bool value);
  private:
  bool _internal_bool_val() const;
  void _internal_set_bool_val(bool value);
  public:

  // int64 int64_val = 2;
  bool has_int64_val() const;
  private:
  bool _internal_has_int64_val() const;
  public:
  void clear_int64_val();
  int64_t int64_val() const;
  void set_int64_val(int64_t value);
  private:
  int64_t _internal_int64_val() const;
  void _internal_set_int64_val(int64_t value);
  public:

  // double float_val = 3;
  bool has_float_val() const;
  private:
  bool _internal_has_float_val() const;
  public:
  void clear_float_val();
  double float_val() const;
  void set_float_val(double value);
  private:
  double _internal_float_val() const;
  void _internal_set_float_val(double value);
  public:

  // string string_val = 4;
  bool has_string_val() const;
  private:
  bool _internal_has_string_val() const;
  public:
  void clear_string_val();
  const std::string& string_val() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_val(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_val();
  PROTOBUF_NODISCARD std::string* release_string_val();
  void set_allocated_string_val(std::string* string_val);
  private:
  const std::string& _internal_string_val() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_val(const std::string& value);
  std::string* _internal_mutable_string_val();
  public:

  void clear_val();
  ValCase val_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.plan.GenericValue)
 private:
  class _Internal;
  void set_has_bool_val();
  void set_has_int64_val();
  void set_has_float_val();
  void set_has_string_val();

  inline bool has_val() const;
  inline void clear_has_val();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ValUnion {
      constexpr ValUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      bool bool_val_;
      int64_t int64_val_;
      double float_val_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_val_;
    } val_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

  inline QueryInfo& operator=(const QueryInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline QueryInfo& operator=(QueryInfo&& 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 QueryInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const QueryInfo* internal_default_instance() {
    return reinterpret_cast<const QueryInfo*>(
               &_QueryInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(QueryInfo& a, QueryInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(QueryInfo* 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(QueryInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  QueryInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<QueryInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const QueryInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const QueryInfo& from) {
    QueryInfo::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(QueryInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.QueryInfo";
  }
  protected:
  explicit QueryInfo(::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 {
    kMetricTypeFieldNumber = 3,
    kSearchParamsFieldNumber = 4,
    kTopkFieldNumber = 1,
    kRoundDecimalFieldNumber = 5,
  };
  // string metric_type = 3;
  void clear_metric_type();
  const std::string& metric_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_metric_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_metric_type();
  PROTOBUF_NODISCARD std::string* release_metric_type();
  void set_allocated_metric_type(std::string* metric_type);
  private:
  const std::string& _internal_metric_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_metric_type(const std::string& value);
  std::string* _internal_mutable_metric_type();
  public:

  // string search_params = 4;
  void clear_search_params();
  const std::string& search_params() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_search_params(ArgT0&& arg0, ArgT... args);
  std::string* mutable_search_params();
  PROTOBUF_NODISCARD std::string* release_search_params();
  void set_allocated_search_params(std::string* search_params);
  private:
  const std::string& _internal_search_params() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_search_params(const std::string& value);
  std::string* _internal_mutable_search_params();
  public:

  // int64 topk = 1;
  void clear_topk();
  int64_t topk() const;
  void set_topk(int64_t value);
  private:
  int64_t _internal_topk() const;
  void _internal_set_topk(int64_t value);
  public:

  // int64 round_decimal = 5;
  void clear_round_decimal();
  int64_t round_decimal() const;
  void set_round_decimal(int64_t value);
  private:
  int64_t _internal_round_decimal() const;
  void _internal_set_round_decimal(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.QueryInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr metric_type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr search_params_;
    int64_t topk_;
    int64_t round_decimal_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ColumnInfo& operator=(const ColumnInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline ColumnInfo& operator=(ColumnInfo&& 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 ColumnInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const ColumnInfo* internal_default_instance() {
    return reinterpret_cast<const ColumnInfo*>(
               &_ColumnInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ColumnInfo& a, ColumnInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(ColumnInfo* 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(ColumnInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ColumnInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ColumnInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ColumnInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ColumnInfo& from) {
    ColumnInfo::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(ColumnInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.ColumnInfo";
  }
  protected:
  explicit ColumnInfo(::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 {
    kFieldIdFieldNumber = 1,
    kDataTypeFieldNumber = 2,
    kIsPrimaryKeyFieldNumber = 3,
    kIsAutoIDFieldNumber = 4,
  };
  // int64 field_id = 1;
  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 data_type = 2;
  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 is_autoID = 4;
  void clear_is_autoid();
  bool is_autoid() const;
  void set_is_autoid(bool value);
  private:
  bool _internal_is_autoid() const;
  void _internal_set_is_autoid(bool value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.ColumnInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t field_id_;
    int data_type_;
    bool is_primary_key_;
    bool is_autoid_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ColumnExpr& operator=(const ColumnExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline ColumnExpr& operator=(ColumnExpr&& 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 ColumnExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const ColumnExpr* internal_default_instance() {
    return reinterpret_cast<const ColumnExpr*>(
               &_ColumnExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ColumnExpr& a, ColumnExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(ColumnExpr* 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(ColumnExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ColumnExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ColumnExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ColumnExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ColumnExpr& from) {
    ColumnExpr::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(ColumnExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.ColumnExpr";
  }
  protected:
  explicit ColumnExpr(::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 {
    kInfoFieldNumber = 1,
  };
  // .milvus.proto.plan.ColumnInfo info = 1;
  bool has_info() const;
  private:
  bool _internal_has_info() const;
  public:
  void clear_info();
  const ::milvus::proto::plan::ColumnInfo& info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_info();
  ::milvus::proto::plan::ColumnInfo* mutable_info();
  void set_allocated_info(::milvus::proto::plan::ColumnInfo* info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_info();
  public:
  void unsafe_arena_set_allocated_info(
      ::milvus::proto::plan::ColumnInfo* info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_info();

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.ColumnExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::ColumnInfo* info_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ValueExpr& operator=(const ValueExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline ValueExpr& operator=(ValueExpr&& 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 ValueExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const ValueExpr* internal_default_instance() {
    return reinterpret_cast<const ValueExpr*>(
               &_ValueExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ValueExpr& a, ValueExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(ValueExpr* 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(ValueExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ValueExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ValueExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ValueExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ValueExpr& from) {
    ValueExpr::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(ValueExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.ValueExpr";
  }
  protected:
  explicit ValueExpr(::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 {
    kValueFieldNumber = 1,
  };
  // .milvus.proto.plan.GenericValue value = 1;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::milvus::proto::plan::GenericValue& value() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_value();
  ::milvus::proto::plan::GenericValue* mutable_value();
  void set_allocated_value(::milvus::proto::plan::GenericValue* value);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_value() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::milvus::proto::plan::GenericValue* value);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_value();

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.ValueExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::GenericValue* value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline UnaryRangeExpr& operator=(const UnaryRangeExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline UnaryRangeExpr& operator=(UnaryRangeExpr&& 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 UnaryRangeExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const UnaryRangeExpr* internal_default_instance() {
    return reinterpret_cast<const UnaryRangeExpr*>(
               &_UnaryRangeExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(UnaryRangeExpr& a, UnaryRangeExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(UnaryRangeExpr* 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(UnaryRangeExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  UnaryRangeExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UnaryRangeExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UnaryRangeExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const UnaryRangeExpr& from) {
    UnaryRangeExpr::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(UnaryRangeExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.UnaryRangeExpr";
  }
  protected:
  explicit UnaryRangeExpr(::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 {
    kColumnInfoFieldNumber = 1,
    kValueFieldNumber = 3,
    kOpFieldNumber = 2,
  };
  // .milvus.proto.plan.ColumnInfo column_info = 1;
  bool has_column_info() const;
  private:
  bool _internal_has_column_info() const;
  public:
  void clear_column_info();
  const ::milvus::proto::plan::ColumnInfo& column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_column_info();
  void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_column_info();
  public:
  void unsafe_arena_set_allocated_column_info(
      ::milvus::proto::plan::ColumnInfo* column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_column_info();

  // .milvus.proto.plan.GenericValue value = 3;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::milvus::proto::plan::GenericValue& value() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_value();
  ::milvus::proto::plan::GenericValue* mutable_value();
  void set_allocated_value(::milvus::proto::plan::GenericValue* value);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_value() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::milvus::proto::plan::GenericValue* value);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_value();

  // .milvus.proto.plan.OpType op = 2;
  void clear_op();
  ::milvus::proto::plan::OpType op() const;
  void set_op(::milvus::proto::plan::OpType value);
  private:
  ::milvus::proto::plan::OpType _internal_op() const;
  void _internal_set_op(::milvus::proto::plan::OpType value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.UnaryRangeExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::ColumnInfo* column_info_;
    ::milvus::proto::plan::GenericValue* value_;
    int op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BinaryRangeExpr& operator=(const BinaryRangeExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline BinaryRangeExpr& operator=(BinaryRangeExpr&& 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 BinaryRangeExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const BinaryRangeExpr* internal_default_instance() {
    return reinterpret_cast<const BinaryRangeExpr*>(
               &_BinaryRangeExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(BinaryRangeExpr& a, BinaryRangeExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(BinaryRangeExpr* 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(BinaryRangeExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BinaryRangeExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BinaryRangeExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BinaryRangeExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BinaryRangeExpr& from) {
    BinaryRangeExpr::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(BinaryRangeExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.BinaryRangeExpr";
  }
  protected:
  explicit BinaryRangeExpr(::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 {
    kColumnInfoFieldNumber = 1,
    kLowerValueFieldNumber = 4,
    kUpperValueFieldNumber = 5,
    kLowerInclusiveFieldNumber = 2,
    kUpperInclusiveFieldNumber = 3,
  };
  // .milvus.proto.plan.ColumnInfo column_info = 1;
  bool has_column_info() const;
  private:
  bool _internal_has_column_info() const;
  public:
  void clear_column_info();
  const ::milvus::proto::plan::ColumnInfo& column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_column_info();
  void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_column_info();
  public:
  void unsafe_arena_set_allocated_column_info(
      ::milvus::proto::plan::ColumnInfo* column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_column_info();

  // .milvus.proto.plan.GenericValue lower_value = 4;
  bool has_lower_value() const;
  private:
  bool _internal_has_lower_value() const;
  public:
  void clear_lower_value();
  const ::milvus::proto::plan::GenericValue& lower_value() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_lower_value();
  ::milvus::proto::plan::GenericValue* mutable_lower_value();
  void set_allocated_lower_value(::milvus::proto::plan::GenericValue* lower_value);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_lower_value() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_lower_value();
  public:
  void unsafe_arena_set_allocated_lower_value(
      ::milvus::proto::plan::GenericValue* lower_value);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_lower_value();

  // .milvus.proto.plan.GenericValue upper_value = 5;
  bool has_upper_value() const;
  private:
  bool _internal_has_upper_value() const;
  public:
  void clear_upper_value();
  const ::milvus::proto::plan::GenericValue& upper_value() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_upper_value();
  ::milvus::proto::plan::GenericValue* mutable_upper_value();
  void set_allocated_upper_value(::milvus::proto::plan::GenericValue* upper_value);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_upper_value() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_upper_value();
  public:
  void unsafe_arena_set_allocated_upper_value(
      ::milvus::proto::plan::GenericValue* upper_value);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_upper_value();

  // bool lower_inclusive = 2;
  void clear_lower_inclusive();
  bool lower_inclusive() const;
  void set_lower_inclusive(bool value);
  private:
  bool _internal_lower_inclusive() const;
  void _internal_set_lower_inclusive(bool value);
  public:

  // bool upper_inclusive = 3;
  void clear_upper_inclusive();
  bool upper_inclusive() const;
  void set_upper_inclusive(bool value);
  private:
  bool _internal_upper_inclusive() const;
  void _internal_set_upper_inclusive(bool value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryRangeExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::ColumnInfo* column_info_;
    ::milvus::proto::plan::GenericValue* lower_value_;
    ::milvus::proto::plan::GenericValue* upper_value_;
    bool lower_inclusive_;
    bool upper_inclusive_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CompareExpr& operator=(const CompareExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompareExpr& operator=(CompareExpr&& from) noexcept {
    if (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 CompareExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompareExpr* internal_default_instance() {
    return reinterpret_cast<const CompareExpr*>(
               &_CompareExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CompareExpr& a, CompareExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CompareExpr* 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(CompareExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CompareExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CompareExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CompareExpr& from) {
    CompareExpr::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(CompareExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.CompareExpr";
  }
  protected:
  explicit CompareExpr(::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 {
    kLeftColumnInfoFieldNumber = 1,
    kRightColumnInfoFieldNumber = 2,
    kOpFieldNumber = 3,
  };
  // .milvus.proto.plan.ColumnInfo left_column_info = 1;
  bool has_left_column_info() const;
  private:
  bool _internal_has_left_column_info() const;
  public:
  void clear_left_column_info();
  const ::milvus::proto::plan::ColumnInfo& left_column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_left_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_left_column_info();
  void set_allocated_left_column_info(::milvus::proto::plan::ColumnInfo* left_column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_left_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_left_column_info();
  public:
  void unsafe_arena_set_allocated_left_column_info(
      ::milvus::proto::plan::ColumnInfo* left_column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_left_column_info();

  // .milvus.proto.plan.ColumnInfo right_column_info = 2;
  bool has_right_column_info() const;
  private:
  bool _internal_has_right_column_info() const;
  public:
  void clear_right_column_info();
  const ::milvus::proto::plan::ColumnInfo& right_column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_right_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_right_column_info();
  void set_allocated_right_column_info(::milvus::proto::plan::ColumnInfo* right_column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_right_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_right_column_info();
  public:
  void unsafe_arena_set_allocated_right_column_info(
      ::milvus::proto::plan::ColumnInfo* right_column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_right_column_info();

  // .milvus.proto.plan.OpType op = 3;
  void clear_op();
  ::milvus::proto::plan::OpType op() const;
  void set_op(::milvus::proto::plan::OpType value);
  private:
  ::milvus::proto::plan::OpType _internal_op() const;
  void _internal_set_op(::milvus::proto::plan::OpType value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::ColumnInfo* left_column_info_;
    ::milvus::proto::plan::ColumnInfo* right_column_info_;
    int op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline TermExpr& operator=(const TermExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline TermExpr& operator=(TermExpr&& 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 TermExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const TermExpr* internal_default_instance() {
    return reinterpret_cast<const TermExpr*>(
               &_TermExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(TermExpr& a, TermExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(TermExpr* 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(TermExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TermExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TermExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TermExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TermExpr& from) {
    TermExpr::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(TermExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.TermExpr";
  }
  protected:
  explicit TermExpr(::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 {
    kValuesFieldNumber = 2,
    kColumnInfoFieldNumber = 1,
  };
  // repeated .milvus.proto.plan.GenericValue values = 2;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  ::milvus::proto::plan::GenericValue* mutable_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::GenericValue >*
      mutable_values();
  private:
  const ::milvus::proto::plan::GenericValue& _internal_values(int index) const;
  ::milvus::proto::plan::GenericValue* _internal_add_values();
  public:
  const ::milvus::proto::plan::GenericValue& values(int index) const;
  ::milvus::proto::plan::GenericValue* add_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::GenericValue >&
      values() const;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  bool has_column_info() const;
  private:
  bool _internal_has_column_info() const;
  public:
  void clear_column_info();
  const ::milvus::proto::plan::ColumnInfo& column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_column_info();
  void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_column_info();
  public:
  void unsafe_arena_set_allocated_column_info(
      ::milvus::proto::plan::ColumnInfo* column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_column_info();

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.TermExpr)
 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::plan::GenericValue > values_;
    ::milvus::proto::plan::ColumnInfo* column_info_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline UnaryExpr& operator=(const UnaryExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline UnaryExpr& operator=(UnaryExpr&& 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 UnaryExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const UnaryExpr* internal_default_instance() {
    return reinterpret_cast<const UnaryExpr*>(
               &_UnaryExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(UnaryExpr& a, UnaryExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(UnaryExpr* 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(UnaryExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  UnaryExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UnaryExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UnaryExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const UnaryExpr& from) {
    UnaryExpr::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(UnaryExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.UnaryExpr";
  }
  protected:
  explicit UnaryExpr(::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 ----------------------------------------------------

  typedef UnaryExpr_UnaryOp UnaryOp;
  static constexpr UnaryOp Invalid =
    UnaryExpr_UnaryOp_Invalid;
  static constexpr UnaryOp Not =
    UnaryExpr_UnaryOp_Not;
  static inline bool UnaryOp_IsValid(int value) {
    return UnaryExpr_UnaryOp_IsValid(value);
  }
  static constexpr UnaryOp UnaryOp_MIN =
    UnaryExpr_UnaryOp_UnaryOp_MIN;
  static constexpr UnaryOp UnaryOp_MAX =
    UnaryExpr_UnaryOp_UnaryOp_MAX;
  static constexpr int UnaryOp_ARRAYSIZE =
    UnaryExpr_UnaryOp_UnaryOp_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  UnaryOp_descriptor() {
    return UnaryExpr_UnaryOp_descriptor();
  }
  template<typename T>
  static inline const std::string& UnaryOp_Name(T enum_t_value) {
    static_assert(::std::is_same<T, UnaryOp>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function UnaryOp_Name.");
    return UnaryExpr_UnaryOp_Name(enum_t_value);
  }
  static inline bool UnaryOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      UnaryOp* value) {
    return UnaryExpr_UnaryOp_Parse(name, value);
  }

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

  enum : int {
    kChildFieldNumber = 2,
    kOpFieldNumber = 1,
  };
  // .milvus.proto.plan.Expr child = 2;
  bool has_child() const;
  private:
  bool _internal_has_child() const;
  public:
  void clear_child();
  const ::milvus::proto::plan::Expr& child() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_child();
  ::milvus::proto::plan::Expr* mutable_child();
  void set_allocated_child(::milvus::proto::plan::Expr* child);
  private:
  const ::milvus::proto::plan::Expr& _internal_child() const;
  ::milvus::proto::plan::Expr* _internal_mutable_child();
  public:
  void unsafe_arena_set_allocated_child(
      ::milvus::proto::plan::Expr* child);
  ::milvus::proto::plan::Expr* unsafe_arena_release_child();

  // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
  void clear_op();
  ::milvus::proto::plan::UnaryExpr_UnaryOp op() const;
  void set_op(::milvus::proto::plan::UnaryExpr_UnaryOp value);
  private:
  ::milvus::proto::plan::UnaryExpr_UnaryOp _internal_op() const;
  void _internal_set_op(::milvus::proto::plan::UnaryExpr_UnaryOp value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.UnaryExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::Expr* child_;
    int op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BinaryExpr& operator=(const BinaryExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline BinaryExpr& operator=(BinaryExpr&& 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 BinaryExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const BinaryExpr* internal_default_instance() {
    return reinterpret_cast<const BinaryExpr*>(
               &_BinaryExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(BinaryExpr& a, BinaryExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(BinaryExpr* 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(BinaryExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BinaryExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BinaryExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BinaryExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BinaryExpr& from) {
    BinaryExpr::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(BinaryExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.BinaryExpr";
  }
  protected:
  explicit BinaryExpr(::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 ----------------------------------------------------

  typedef BinaryExpr_BinaryOp BinaryOp;
  static constexpr BinaryOp Invalid =
    BinaryExpr_BinaryOp_Invalid;
  static constexpr BinaryOp LogicalAnd =
    BinaryExpr_BinaryOp_LogicalAnd;
  static constexpr BinaryOp LogicalOr =
    BinaryExpr_BinaryOp_LogicalOr;
  static inline bool BinaryOp_IsValid(int value) {
    return BinaryExpr_BinaryOp_IsValid(value);
  }
  static constexpr BinaryOp BinaryOp_MIN =
    BinaryExpr_BinaryOp_BinaryOp_MIN;
  static constexpr BinaryOp BinaryOp_MAX =
    BinaryExpr_BinaryOp_BinaryOp_MAX;
  static constexpr int BinaryOp_ARRAYSIZE =
    BinaryExpr_BinaryOp_BinaryOp_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  BinaryOp_descriptor() {
    return BinaryExpr_BinaryOp_descriptor();
  }
  template<typename T>
  static inline const std::string& BinaryOp_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BinaryOp>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BinaryOp_Name.");
    return BinaryExpr_BinaryOp_Name(enum_t_value);
  }
  static inline bool BinaryOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      BinaryOp* value) {
    return BinaryExpr_BinaryOp_Parse(name, value);
  }

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

  enum : int {
    kLeftFieldNumber = 2,
    kRightFieldNumber = 3,
    kOpFieldNumber = 1,
  };
  // .milvus.proto.plan.Expr left = 2;
  bool has_left() const;
  private:
  bool _internal_has_left() const;
  public:
  void clear_left();
  const ::milvus::proto::plan::Expr& left() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_left();
  ::milvus::proto::plan::Expr* mutable_left();
  void set_allocated_left(::milvus::proto::plan::Expr* left);
  private:
  const ::milvus::proto::plan::Expr& _internal_left() const;
  ::milvus::proto::plan::Expr* _internal_mutable_left();
  public:
  void unsafe_arena_set_allocated_left(
      ::milvus::proto::plan::Expr* left);
  ::milvus::proto::plan::Expr* unsafe_arena_release_left();

  // .milvus.proto.plan.Expr right = 3;
  bool has_right() const;
  private:
  bool _internal_has_right() const;
  public:
  void clear_right();
  const ::milvus::proto::plan::Expr& right() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_right();
  ::milvus::proto::plan::Expr* mutable_right();
  void set_allocated_right(::milvus::proto::plan::Expr* right);
  private:
  const ::milvus::proto::plan::Expr& _internal_right() const;
  ::milvus::proto::plan::Expr* _internal_mutable_right();
  public:
  void unsafe_arena_set_allocated_right(
      ::milvus::proto::plan::Expr* right);
  ::milvus::proto::plan::Expr* unsafe_arena_release_right();

  // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
  void clear_op();
  ::milvus::proto::plan::BinaryExpr_BinaryOp op() const;
  void set_op(::milvus::proto::plan::BinaryExpr_BinaryOp value);
  private:
  ::milvus::proto::plan::BinaryExpr_BinaryOp _internal_op() const;
  void _internal_set_op(::milvus::proto::plan::BinaryExpr_BinaryOp value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::Expr* left_;
    ::milvus::proto::plan::Expr* right_;
    int op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BinaryArithOp& operator=(const BinaryArithOp& from) {
    CopyFrom(from);
    return *this;
  }
  inline BinaryArithOp& operator=(BinaryArithOp&& 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 BinaryArithOp& default_instance() {
    return *internal_default_instance();
  }
  static inline const BinaryArithOp* internal_default_instance() {
    return reinterpret_cast<const BinaryArithOp*>(
               &_BinaryArithOp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(BinaryArithOp& a, BinaryArithOp& b) {
    a.Swap(&b);
  }
  inline void Swap(BinaryArithOp* 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(BinaryArithOp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BinaryArithOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BinaryArithOp>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BinaryArithOp& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BinaryArithOp& from) {
    BinaryArithOp::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(BinaryArithOp* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.BinaryArithOp";
  }
  protected:
  explicit BinaryArithOp(::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 {
    kColumnInfoFieldNumber = 1,
    kRightOperandFieldNumber = 3,
    kArithOpFieldNumber = 2,
  };
  // .milvus.proto.plan.ColumnInfo column_info = 1;
  bool has_column_info() const;
  private:
  bool _internal_has_column_info() const;
  public:
  void clear_column_info();
  const ::milvus::proto::plan::ColumnInfo& column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_column_info();
  void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_column_info();
  public:
  void unsafe_arena_set_allocated_column_info(
      ::milvus::proto::plan::ColumnInfo* column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_column_info();

  // .milvus.proto.plan.GenericValue right_operand = 3;
  bool has_right_operand() const;
  private:
  bool _internal_has_right_operand() const;
  public:
  void clear_right_operand();
  const ::milvus::proto::plan::GenericValue& right_operand() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_right_operand();
  ::milvus::proto::plan::GenericValue* mutable_right_operand();
  void set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_right_operand() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_right_operand();
  public:
  void unsafe_arena_set_allocated_right_operand(
      ::milvus::proto::plan::GenericValue* right_operand);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_right_operand();

  // .milvus.proto.plan.ArithOpType arith_op = 2;
  void clear_arith_op();
  ::milvus::proto::plan::ArithOpType arith_op() const;
  void set_arith_op(::milvus::proto::plan::ArithOpType value);
  private:
  ::milvus::proto::plan::ArithOpType _internal_arith_op() const;
  void _internal_set_arith_op(::milvus::proto::plan::ArithOpType value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryArithOp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::ColumnInfo* column_info_;
    ::milvus::proto::plan::GenericValue* right_operand_;
    int arith_op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BinaryArithExpr& operator=(const BinaryArithExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline BinaryArithExpr& operator=(BinaryArithExpr&& 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 BinaryArithExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const BinaryArithExpr* internal_default_instance() {
    return reinterpret_cast<const BinaryArithExpr*>(
               &_BinaryArithExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(BinaryArithExpr& a, BinaryArithExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(BinaryArithExpr* 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(BinaryArithExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BinaryArithExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BinaryArithExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BinaryArithExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BinaryArithExpr& from) {
    BinaryArithExpr::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(BinaryArithExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.BinaryArithExpr";
  }
  protected:
  explicit BinaryArithExpr(::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 {
    kLeftFieldNumber = 1,
    kRightFieldNumber = 2,
    kOpFieldNumber = 3,
  };
  // .milvus.proto.plan.Expr left = 1;
  bool has_left() const;
  private:
  bool _internal_has_left() const;
  public:
  void clear_left();
  const ::milvus::proto::plan::Expr& left() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_left();
  ::milvus::proto::plan::Expr* mutable_left();
  void set_allocated_left(::milvus::proto::plan::Expr* left);
  private:
  const ::milvus::proto::plan::Expr& _internal_left() const;
  ::milvus::proto::plan::Expr* _internal_mutable_left();
  public:
  void unsafe_arena_set_allocated_left(
      ::milvus::proto::plan::Expr* left);
  ::milvus::proto::plan::Expr* unsafe_arena_release_left();

  // .milvus.proto.plan.Expr right = 2;
  bool has_right() const;
  private:
  bool _internal_has_right() const;
  public:
  void clear_right();
  const ::milvus::proto::plan::Expr& right() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_right();
  ::milvus::proto::plan::Expr* mutable_right();
  void set_allocated_right(::milvus::proto::plan::Expr* right);
  private:
  const ::milvus::proto::plan::Expr& _internal_right() const;
  ::milvus::proto::plan::Expr* _internal_mutable_right();
  public:
  void unsafe_arena_set_allocated_right(
      ::milvus::proto::plan::Expr* right);
  ::milvus::proto::plan::Expr* unsafe_arena_release_right();

  // .milvus.proto.plan.ArithOpType op = 3;
  void clear_op();
  ::milvus::proto::plan::ArithOpType op() const;
  void set_op(::milvus::proto::plan::ArithOpType value);
  private:
  ::milvus::proto::plan::ArithOpType _internal_op() const;
  void _internal_set_op(::milvus::proto::plan::ArithOpType value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryArithExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::Expr* left_;
    ::milvus::proto::plan::Expr* right_;
    int op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BinaryArithOpEvalRangeExpr& operator=(const BinaryArithOpEvalRangeExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline BinaryArithOpEvalRangeExpr& operator=(BinaryArithOpEvalRangeExpr&& 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 BinaryArithOpEvalRangeExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const BinaryArithOpEvalRangeExpr* internal_default_instance() {
    return reinterpret_cast<const BinaryArithOpEvalRangeExpr*>(
               &_BinaryArithOpEvalRangeExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(BinaryArithOpEvalRangeExpr& a, BinaryArithOpEvalRangeExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(BinaryArithOpEvalRangeExpr* 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(BinaryArithOpEvalRangeExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BinaryArithOpEvalRangeExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BinaryArithOpEvalRangeExpr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BinaryArithOpEvalRangeExpr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BinaryArithOpEvalRangeExpr& from) {
    BinaryArithOpEvalRangeExpr::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(BinaryArithOpEvalRangeExpr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.BinaryArithOpEvalRangeExpr";
  }
  protected:
  explicit BinaryArithOpEvalRangeExpr(::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 {
    kColumnInfoFieldNumber = 1,
    kRightOperandFieldNumber = 3,
    kValueFieldNumber = 5,
    kArithOpFieldNumber = 2,
    kOpFieldNumber = 4,
  };
  // .milvus.proto.plan.ColumnInfo column_info = 1;
  bool has_column_info() const;
  private:
  bool _internal_has_column_info() const;
  public:
  void clear_column_info();
  const ::milvus::proto::plan::ColumnInfo& column_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnInfo* release_column_info();
  ::milvus::proto::plan::ColumnInfo* mutable_column_info();
  void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info);
  private:
  const ::milvus::proto::plan::ColumnInfo& _internal_column_info() const;
  ::milvus::proto::plan::ColumnInfo* _internal_mutable_column_info();
  public:
  void unsafe_arena_set_allocated_column_info(
      ::milvus::proto::plan::ColumnInfo* column_info);
  ::milvus::proto::plan::ColumnInfo* unsafe_arena_release_column_info();

  // .milvus.proto.plan.GenericValue right_operand = 3;
  bool has_right_operand() const;
  private:
  bool _internal_has_right_operand() const;
  public:
  void clear_right_operand();
  const ::milvus::proto::plan::GenericValue& right_operand() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_right_operand();
  ::milvus::proto::plan::GenericValue* mutable_right_operand();
  void set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_right_operand() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_right_operand();
  public:
  void unsafe_arena_set_allocated_right_operand(
      ::milvus::proto::plan::GenericValue* right_operand);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_right_operand();

  // .milvus.proto.plan.GenericValue value = 5;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::milvus::proto::plan::GenericValue& value() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::GenericValue* release_value();
  ::milvus::proto::plan::GenericValue* mutable_value();
  void set_allocated_value(::milvus::proto::plan::GenericValue* value);
  private:
  const ::milvus::proto::plan::GenericValue& _internal_value() const;
  ::milvus::proto::plan::GenericValue* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::milvus::proto::plan::GenericValue* value);
  ::milvus::proto::plan::GenericValue* unsafe_arena_release_value();

  // .milvus.proto.plan.ArithOpType arith_op = 2;
  void clear_arith_op();
  ::milvus::proto::plan::ArithOpType arith_op() const;
  void set_arith_op(::milvus::proto::plan::ArithOpType value);
  private:
  ::milvus::proto::plan::ArithOpType _internal_arith_op() const;
  void _internal_set_arith_op(::milvus::proto::plan::ArithOpType value);
  public:

  // .milvus.proto.plan.OpType op = 4;
  void clear_op();
  ::milvus::proto::plan::OpType op() const;
  void set_op(::milvus::proto::plan::OpType value);
  private:
  ::milvus::proto::plan::OpType _internal_op() const;
  void _internal_set_op(::milvus::proto::plan::OpType value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::ColumnInfo* column_info_;
    ::milvus::proto::plan::GenericValue* right_operand_;
    ::milvus::proto::plan::GenericValue* value_;
    int arith_op_;
    int op_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Expr& operator=(const Expr& from) {
    CopyFrom(from);
    return *this;
  }
  inline Expr& operator=(Expr&& 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 Expr& default_instance() {
    return *internal_default_instance();
  }
  enum ExprCase {
    kTermExpr = 1,
    kUnaryExpr = 2,
    kBinaryExpr = 3,
    kCompareExpr = 4,
    kUnaryRangeExpr = 5,
    kBinaryRangeExpr = 6,
    kBinaryArithOpEvalRangeExpr = 7,
    kBinaryArithExpr = 8,
    kValueExpr = 9,
    kColumnExpr = 10,
    EXPR_NOT_SET = 0,
  };

  static inline const Expr* internal_default_instance() {
    return reinterpret_cast<const Expr*>(
               &_Expr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(Expr& a, Expr& b) {
    a.Swap(&b);
  }
  inline void Swap(Expr* 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(Expr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Expr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Expr>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Expr& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Expr& from) {
    Expr::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(Expr* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.Expr";
  }
  protected:
  explicit Expr(::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 {
    kTermExprFieldNumber = 1,
    kUnaryExprFieldNumber = 2,
    kBinaryExprFieldNumber = 3,
    kCompareExprFieldNumber = 4,
    kUnaryRangeExprFieldNumber = 5,
    kBinaryRangeExprFieldNumber = 6,
    kBinaryArithOpEvalRangeExprFieldNumber = 7,
    kBinaryArithExprFieldNumber = 8,
    kValueExprFieldNumber = 9,
    kColumnExprFieldNumber = 10,
  };
  // .milvus.proto.plan.TermExpr term_expr = 1;
  bool has_term_expr() const;
  private:
  bool _internal_has_term_expr() const;
  public:
  void clear_term_expr();
  const ::milvus::proto::plan::TermExpr& term_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::TermExpr* release_term_expr();
  ::milvus::proto::plan::TermExpr* mutable_term_expr();
  void set_allocated_term_expr(::milvus::proto::plan::TermExpr* term_expr);
  private:
  const ::milvus::proto::plan::TermExpr& _internal_term_expr() const;
  ::milvus::proto::plan::TermExpr* _internal_mutable_term_expr();
  public:
  void unsafe_arena_set_allocated_term_expr(
      ::milvus::proto::plan::TermExpr* term_expr);
  ::milvus::proto::plan::TermExpr* unsafe_arena_release_term_expr();

  // .milvus.proto.plan.UnaryExpr unary_expr = 2;
  bool has_unary_expr() const;
  private:
  bool _internal_has_unary_expr() const;
  public:
  void clear_unary_expr();
  const ::milvus::proto::plan::UnaryExpr& unary_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::UnaryExpr* release_unary_expr();
  ::milvus::proto::plan::UnaryExpr* mutable_unary_expr();
  void set_allocated_unary_expr(::milvus::proto::plan::UnaryExpr* unary_expr);
  private:
  const ::milvus::proto::plan::UnaryExpr& _internal_unary_expr() const;
  ::milvus::proto::plan::UnaryExpr* _internal_mutable_unary_expr();
  public:
  void unsafe_arena_set_allocated_unary_expr(
      ::milvus::proto::plan::UnaryExpr* unary_expr);
  ::milvus::proto::plan::UnaryExpr* unsafe_arena_release_unary_expr();

  // .milvus.proto.plan.BinaryExpr binary_expr = 3;
  bool has_binary_expr() const;
  private:
  bool _internal_has_binary_expr() const;
  public:
  void clear_binary_expr();
  const ::milvus::proto::plan::BinaryExpr& binary_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::BinaryExpr* release_binary_expr();
  ::milvus::proto::plan::BinaryExpr* mutable_binary_expr();
  void set_allocated_binary_expr(::milvus::proto::plan::BinaryExpr* binary_expr);
  private:
  const ::milvus::proto::plan::BinaryExpr& _internal_binary_expr() const;
  ::milvus::proto::plan::BinaryExpr* _internal_mutable_binary_expr();
  public:
  void unsafe_arena_set_allocated_binary_expr(
      ::milvus::proto::plan::BinaryExpr* binary_expr);
  ::milvus::proto::plan::BinaryExpr* unsafe_arena_release_binary_expr();

  // .milvus.proto.plan.CompareExpr compare_expr = 4;
  bool has_compare_expr() const;
  private:
  bool _internal_has_compare_expr() const;
  public:
  void clear_compare_expr();
  const ::milvus::proto::plan::CompareExpr& compare_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::CompareExpr* release_compare_expr();
  ::milvus::proto::plan::CompareExpr* mutable_compare_expr();
  void set_allocated_compare_expr(::milvus::proto::plan::CompareExpr* compare_expr);
  private:
  const ::milvus::proto::plan::CompareExpr& _internal_compare_expr() const;
  ::milvus::proto::plan::CompareExpr* _internal_mutable_compare_expr();
  public:
  void unsafe_arena_set_allocated_compare_expr(
      ::milvus::proto::plan::CompareExpr* compare_expr);
  ::milvus::proto::plan::CompareExpr* unsafe_arena_release_compare_expr();

  // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
  bool has_unary_range_expr() const;
  private:
  bool _internal_has_unary_range_expr() const;
  public:
  void clear_unary_range_expr();
  const ::milvus::proto::plan::UnaryRangeExpr& unary_range_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::UnaryRangeExpr* release_unary_range_expr();
  ::milvus::proto::plan::UnaryRangeExpr* mutable_unary_range_expr();
  void set_allocated_unary_range_expr(::milvus::proto::plan::UnaryRangeExpr* unary_range_expr);
  private:
  const ::milvus::proto::plan::UnaryRangeExpr& _internal_unary_range_expr() const;
  ::milvus::proto::plan::UnaryRangeExpr* _internal_mutable_unary_range_expr();
  public:
  void unsafe_arena_set_allocated_unary_range_expr(
      ::milvus::proto::plan::UnaryRangeExpr* unary_range_expr);
  ::milvus::proto::plan::UnaryRangeExpr* unsafe_arena_release_unary_range_expr();

  // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
  bool has_binary_range_expr() const;
  private:
  bool _internal_has_binary_range_expr() const;
  public:
  void clear_binary_range_expr();
  const ::milvus::proto::plan::BinaryRangeExpr& binary_range_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::BinaryRangeExpr* release_binary_range_expr();
  ::milvus::proto::plan::BinaryRangeExpr* mutable_binary_range_expr();
  void set_allocated_binary_range_expr(::milvus::proto::plan::BinaryRangeExpr* binary_range_expr);
  private:
  const ::milvus::proto::plan::BinaryRangeExpr& _internal_binary_range_expr() const;
  ::milvus::proto::plan::BinaryRangeExpr* _internal_mutable_binary_range_expr();
  public:
  void unsafe_arena_set_allocated_binary_range_expr(
      ::milvus::proto::plan::BinaryRangeExpr* binary_range_expr);
  ::milvus::proto::plan::BinaryRangeExpr* unsafe_arena_release_binary_range_expr();

  // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7;
  bool has_binary_arith_op_eval_range_expr() const;
  private:
  bool _internal_has_binary_arith_op_eval_range_expr() const;
  public:
  void clear_binary_arith_op_eval_range_expr();
  const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& binary_arith_op_eval_range_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* release_binary_arith_op_eval_range_expr();
  ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* mutable_binary_arith_op_eval_range_expr();
  void set_allocated_binary_arith_op_eval_range_expr(::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr);
  private:
  const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& _internal_binary_arith_op_eval_range_expr() const;
  ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* _internal_mutable_binary_arith_op_eval_range_expr();
  public:
  void unsafe_arena_set_allocated_binary_arith_op_eval_range_expr(
      ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr);
  ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* unsafe_arena_release_binary_arith_op_eval_range_expr();

  // .milvus.proto.plan.BinaryArithExpr binary_arith_expr = 8;
  bool has_binary_arith_expr() const;
  private:
  bool _internal_has_binary_arith_expr() const;
  public:
  void clear_binary_arith_expr();
  const ::milvus::proto::plan::BinaryArithExpr& binary_arith_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::BinaryArithExpr* release_binary_arith_expr();
  ::milvus::proto::plan::BinaryArithExpr* mutable_binary_arith_expr();
  void set_allocated_binary_arith_expr(::milvus::proto::plan::BinaryArithExpr* binary_arith_expr);
  private:
  const ::milvus::proto::plan::BinaryArithExpr& _internal_binary_arith_expr() const;
  ::milvus::proto::plan::BinaryArithExpr* _internal_mutable_binary_arith_expr();
  public:
  void unsafe_arena_set_allocated_binary_arith_expr(
      ::milvus::proto::plan::BinaryArithExpr* binary_arith_expr);
  ::milvus::proto::plan::BinaryArithExpr* unsafe_arena_release_binary_arith_expr();

  // .milvus.proto.plan.ValueExpr value_expr = 9;
  bool has_value_expr() const;
  private:
  bool _internal_has_value_expr() const;
  public:
  void clear_value_expr();
  const ::milvus::proto::plan::ValueExpr& value_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ValueExpr* release_value_expr();
  ::milvus::proto::plan::ValueExpr* mutable_value_expr();
  void set_allocated_value_expr(::milvus::proto::plan::ValueExpr* value_expr);
  private:
  const ::milvus::proto::plan::ValueExpr& _internal_value_expr() const;
  ::milvus::proto::plan::ValueExpr* _internal_mutable_value_expr();
  public:
  void unsafe_arena_set_allocated_value_expr(
      ::milvus::proto::plan::ValueExpr* value_expr);
  ::milvus::proto::plan::ValueExpr* unsafe_arena_release_value_expr();

  // .milvus.proto.plan.ColumnExpr column_expr = 10;
  bool has_column_expr() const;
  private:
  bool _internal_has_column_expr() const;
  public:
  void clear_column_expr();
  const ::milvus::proto::plan::ColumnExpr& column_expr() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::ColumnExpr* release_column_expr();
  ::milvus::proto::plan::ColumnExpr* mutable_column_expr();
  void set_allocated_column_expr(::milvus::proto::plan::ColumnExpr* column_expr);
  private:
  const ::milvus::proto::plan::ColumnExpr& _internal_column_expr() const;
  ::milvus::proto::plan::ColumnExpr* _internal_mutable_column_expr();
  public:
  void unsafe_arena_set_allocated_column_expr(
      ::milvus::proto::plan::ColumnExpr* column_expr);
  ::milvus::proto::plan::ColumnExpr* unsafe_arena_release_column_expr();

  void clear_expr();
  ExprCase expr_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.plan.Expr)
 private:
  class _Internal;
  void set_has_term_expr();
  void set_has_unary_expr();
  void set_has_binary_expr();
  void set_has_compare_expr();
  void set_has_unary_range_expr();
  void set_has_binary_range_expr();
  void set_has_binary_arith_op_eval_range_expr();
  void set_has_binary_arith_expr();
  void set_has_value_expr();
  void set_has_column_expr();

  inline bool has_expr() const;
  inline void clear_has_expr();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ExprUnion {
      constexpr ExprUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::milvus::proto::plan::TermExpr* term_expr_;
      ::milvus::proto::plan::UnaryExpr* unary_expr_;
      ::milvus::proto::plan::BinaryExpr* binary_expr_;
      ::milvus::proto::plan::CompareExpr* compare_expr_;
      ::milvus::proto::plan::UnaryRangeExpr* unary_range_expr_;
      ::milvus::proto::plan::BinaryRangeExpr* binary_range_expr_;
      ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr_;
      ::milvus::proto::plan::BinaryArithExpr* binary_arith_expr_;
      ::milvus::proto::plan::ValueExpr* value_expr_;
      ::milvus::proto::plan::ColumnExpr* column_expr_;
    } expr_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

  inline VectorANNS& operator=(const VectorANNS& from) {
    CopyFrom(from);
    return *this;
  }
  inline VectorANNS& operator=(VectorANNS&& 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 VectorANNS& default_instance() {
    return *internal_default_instance();
  }
  static inline const VectorANNS* internal_default_instance() {
    return reinterpret_cast<const VectorANNS*>(
               &_VectorANNS_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(VectorANNS& a, VectorANNS& b) {
    a.Swap(&b);
  }
  inline void Swap(VectorANNS* 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(VectorANNS* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  VectorANNS* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VectorANNS>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VectorANNS& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const VectorANNS& from) {
    VectorANNS::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(VectorANNS* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.VectorANNS";
  }
  protected:
  explicit VectorANNS(::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 {
    kPlaceholderTagFieldNumber = 5,
    kPredicatesFieldNumber = 3,
    kQueryInfoFieldNumber = 4,
    kFieldIdFieldNumber = 2,
    kIsBinaryFieldNumber = 1,
  };
  // string placeholder_tag = 5;
  void clear_placeholder_tag();
  const std::string& placeholder_tag() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_placeholder_tag(ArgT0&& arg0, ArgT... args);
  std::string* mutable_placeholder_tag();
  PROTOBUF_NODISCARD std::string* release_placeholder_tag();
  void set_allocated_placeholder_tag(std::string* placeholder_tag);
  private:
  const std::string& _internal_placeholder_tag() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_placeholder_tag(const std::string& value);
  std::string* _internal_mutable_placeholder_tag();
  public:

  // .milvus.proto.plan.Expr predicates = 3;
  bool has_predicates() const;
  private:
  bool _internal_has_predicates() const;
  public:
  void clear_predicates();
  const ::milvus::proto::plan::Expr& predicates() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_predicates();
  ::milvus::proto::plan::Expr* mutable_predicates();
  void set_allocated_predicates(::milvus::proto::plan::Expr* predicates);
  private:
  const ::milvus::proto::plan::Expr& _internal_predicates() const;
  ::milvus::proto::plan::Expr* _internal_mutable_predicates();
  public:
  void unsafe_arena_set_allocated_predicates(
      ::milvus::proto::plan::Expr* predicates);
  ::milvus::proto::plan::Expr* unsafe_arena_release_predicates();

  // .milvus.proto.plan.QueryInfo query_info = 4;
  bool has_query_info() const;
  private:
  bool _internal_has_query_info() const;
  public:
  void clear_query_info();
  const ::milvus::proto::plan::QueryInfo& query_info() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::QueryInfo* release_query_info();
  ::milvus::proto::plan::QueryInfo* mutable_query_info();
  void set_allocated_query_info(::milvus::proto::plan::QueryInfo* query_info);
  private:
  const ::milvus::proto::plan::QueryInfo& _internal_query_info() const;
  ::milvus::proto::plan::QueryInfo* _internal_mutable_query_info();
  public:
  void unsafe_arena_set_allocated_query_info(
      ::milvus::proto::plan::QueryInfo* query_info);
  ::milvus::proto::plan::QueryInfo* unsafe_arena_release_query_info();

  // int64 field_id = 2;
  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:

  // bool is_binary = 1;
  void clear_is_binary();
  bool is_binary() const;
  void set_is_binary(bool value);
  private:
  bool _internal_is_binary() const;
  void _internal_set_is_binary(bool value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.VectorANNS)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr placeholder_tag_;
    ::milvus::proto::plan::Expr* predicates_;
    ::milvus::proto::plan::QueryInfo* query_info_;
    int64_t field_id_;
    bool is_binary_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline QueryPlanNode& operator=(const QueryPlanNode& from) {
    CopyFrom(from);
    return *this;
  }
  inline QueryPlanNode& operator=(QueryPlanNode&& 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 QueryPlanNode& default_instance() {
    return *internal_default_instance();
  }
  static inline const QueryPlanNode* internal_default_instance() {
    return reinterpret_cast<const QueryPlanNode*>(
               &_QueryPlanNode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(QueryPlanNode& a, QueryPlanNode& b) {
    a.Swap(&b);
  }
  inline void Swap(QueryPlanNode* 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(QueryPlanNode* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  QueryPlanNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<QueryPlanNode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const QueryPlanNode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const QueryPlanNode& from) {
    QueryPlanNode::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(QueryPlanNode* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.QueryPlanNode";
  }
  protected:
  explicit QueryPlanNode(::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 {
    kPredicatesFieldNumber = 1,
    kIsCountFieldNumber = 2,
  };
  // .milvus.proto.plan.Expr predicates = 1;
  bool has_predicates() const;
  private:
  bool _internal_has_predicates() const;
  public:
  void clear_predicates();
  const ::milvus::proto::plan::Expr& predicates() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_predicates();
  ::milvus::proto::plan::Expr* mutable_predicates();
  void set_allocated_predicates(::milvus::proto::plan::Expr* predicates);
  private:
  const ::milvus::proto::plan::Expr& _internal_predicates() const;
  ::milvus::proto::plan::Expr* _internal_mutable_predicates();
  public:
  void unsafe_arena_set_allocated_predicates(
      ::milvus::proto::plan::Expr* predicates);
  ::milvus::proto::plan::Expr* unsafe_arena_release_predicates();

  // bool is_count = 2;
  void clear_is_count();
  bool is_count() const;
  void set_is_count(bool value);
  private:
  bool _internal_is_count() const;
  void _internal_set_is_count(bool value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.plan.QueryPlanNode)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::plan::Expr* predicates_;
    bool is_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline PlanNode& operator=(const PlanNode& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlanNode& operator=(PlanNode&& 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 PlanNode& default_instance() {
    return *internal_default_instance();
  }
  enum NodeCase {
    kVectorAnns = 1,
    kPredicates = 2,
    kQuery = 4,
    NODE_NOT_SET = 0,
  };

  static inline const PlanNode* internal_default_instance() {
    return reinterpret_cast<const PlanNode*>(
               &_PlanNode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(PlanNode& a, PlanNode& b) {
    a.Swap(&b);
  }
  inline void Swap(PlanNode* 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(PlanNode* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PlanNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PlanNode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PlanNode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PlanNode& from) {
    PlanNode::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(PlanNode* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.plan.PlanNode";
  }
  protected:
  explicit PlanNode(::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 {
    kOutputFieldIdsFieldNumber = 3,
    kVectorAnnsFieldNumber = 1,
    kPredicatesFieldNumber = 2,
    kQueryFieldNumber = 4,
  };
  // repeated int64 output_field_ids = 3;
  int output_field_ids_size() const;
  private:
  int _internal_output_field_ids_size() const;
  public:
  void clear_output_field_ids();
  private:
  int64_t _internal_output_field_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_output_field_ids() const;
  void _internal_add_output_field_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_output_field_ids();
  public:
  int64_t output_field_ids(int index) const;
  void set_output_field_ids(int index, int64_t value);
  void add_output_field_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      output_field_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_output_field_ids();

  // .milvus.proto.plan.VectorANNS vector_anns = 1;
  bool has_vector_anns() const;
  private:
  bool _internal_has_vector_anns() const;
  public:
  void clear_vector_anns();
  const ::milvus::proto::plan::VectorANNS& vector_anns() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::VectorANNS* release_vector_anns();
  ::milvus::proto::plan::VectorANNS* mutable_vector_anns();
  void set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns);
  private:
  const ::milvus::proto::plan::VectorANNS& _internal_vector_anns() const;
  ::milvus::proto::plan::VectorANNS* _internal_mutable_vector_anns();
  public:
  void unsafe_arena_set_allocated_vector_anns(
      ::milvus::proto::plan::VectorANNS* vector_anns);
  ::milvus::proto::plan::VectorANNS* unsafe_arena_release_vector_anns();

  // .milvus.proto.plan.Expr predicates = 2;
  bool has_predicates() const;
  private:
  bool _internal_has_predicates() const;
  public:
  void clear_predicates();
  const ::milvus::proto::plan::Expr& predicates() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::Expr* release_predicates();
  ::milvus::proto::plan::Expr* mutable_predicates();
  void set_allocated_predicates(::milvus::proto::plan::Expr* predicates);
  private:
  const ::milvus::proto::plan::Expr& _internal_predicates() const;
  ::milvus::proto::plan::Expr* _internal_mutable_predicates();
  public:
  void unsafe_arena_set_allocated_predicates(
      ::milvus::proto::plan::Expr* predicates);
  ::milvus::proto::plan::Expr* unsafe_arena_release_predicates();

  // .milvus.proto.plan.QueryPlanNode query = 4;
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::milvus::proto::plan::QueryPlanNode& query() const;
  PROTOBUF_NODISCARD ::milvus::proto::plan::QueryPlanNode* release_query();
  ::milvus::proto::plan::QueryPlanNode* mutable_query();
  void set_allocated_query(::milvus::proto::plan::QueryPlanNode* query);
  private:
  const ::milvus::proto::plan::QueryPlanNode& _internal_query() const;
  ::milvus::proto::plan::QueryPlanNode* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::milvus::proto::plan::QueryPlanNode* query);
  ::milvus::proto::plan::QueryPlanNode* unsafe_arena_release_query();

  void clear_node();
  NodeCase node_case() const;
  // @@protoc_insertion_point(class_scope:milvus.proto.plan.PlanNode)
 private:
  class _Internal;
  void set_has_vector_anns();
  void set_has_predicates();
  void set_has_query();

  inline bool has_node() const;
  inline void clear_has_node();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > output_field_ids_;
    mutable std::atomic<int> _output_field_ids_cached_byte_size_;
    union NodeUnion {
      constexpr NodeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::milvus::proto::plan::VectorANNS* vector_anns_;
      ::milvus::proto::plan::Expr* predicates_;
      ::milvus::proto::plan::QueryPlanNode* query_;
    } node_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_plan_2eproto;
};
// ===================================================================


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

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

// bool bool_val = 1;
inline bool GenericValue::_internal_has_bool_val() const {
  return val_case() == kBoolVal;
}
inline bool GenericValue::has_bool_val() const {
  return _internal_has_bool_val();
}
inline void GenericValue::set_has_bool_val() {
  _impl_._oneof_case_[0] = kBoolVal;
}
inline void GenericValue::clear_bool_val() {
  if (_internal_has_bool_val()) {
    _impl_.val_.bool_val_ = false;
    clear_has_val();
  }
}
inline bool GenericValue::_internal_bool_val() const {
  if (_internal_has_bool_val()) {
    return _impl_.val_.bool_val_;
  }
  return false;
}
inline void GenericValue::_internal_set_bool_val(bool value) {
  if (!_internal_has_bool_val()) {
    clear_val();
    set_has_bool_val();
  }
  _impl_.val_.bool_val_ = value;
}
inline bool GenericValue::bool_val() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.GenericValue.bool_val)
  return _internal_bool_val();
}
inline void GenericValue::set_bool_val(bool value) {
  _internal_set_bool_val(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.GenericValue.bool_val)
}

// int64 int64_val = 2;
inline bool GenericValue::_internal_has_int64_val() const {
  return val_case() == kInt64Val;
}
inline bool GenericValue::has_int64_val() const {
  return _internal_has_int64_val();
}
inline void GenericValue::set_has_int64_val() {
  _impl_._oneof_case_[0] = kInt64Val;
}
inline void GenericValue::clear_int64_val() {
  if (_internal_has_int64_val()) {
    _impl_.val_.int64_val_ = int64_t{0};
    clear_has_val();
  }
}
inline int64_t GenericValue::_internal_int64_val() const {
  if (_internal_has_int64_val()) {
    return _impl_.val_.int64_val_;
  }
  return int64_t{0};
}
inline void GenericValue::_internal_set_int64_val(int64_t value) {
  if (!_internal_has_int64_val()) {
    clear_val();
    set_has_int64_val();
  }
  _impl_.val_.int64_val_ = value;
}
inline int64_t GenericValue::int64_val() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.GenericValue.int64_val)
  return _internal_int64_val();
}
inline void GenericValue::set_int64_val(int64_t value) {
  _internal_set_int64_val(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.GenericValue.int64_val)
}

// double float_val = 3;
inline bool GenericValue::_internal_has_float_val() const {
  return val_case() == kFloatVal;
}
inline bool GenericValue::has_float_val() const {
  return _internal_has_float_val();
}
inline void GenericValue::set_has_float_val() {
  _impl_._oneof_case_[0] = kFloatVal;
}
inline void GenericValue::clear_float_val() {
  if (_internal_has_float_val()) {
    _impl_.val_.float_val_ = 0;
    clear_has_val();
  }
}
inline double GenericValue::_internal_float_val() const {
  if (_internal_has_float_val()) {
    return _impl_.val_.float_val_;
  }
  return 0;
}
inline void GenericValue::_internal_set_float_val(double value) {
  if (!_internal_has_float_val()) {
    clear_val();
    set_has_float_val();
  }
  _impl_.val_.float_val_ = value;
}
inline double GenericValue::float_val() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.GenericValue.float_val)
  return _internal_float_val();
}
inline void GenericValue::set_float_val(double value) {
  _internal_set_float_val(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.GenericValue.float_val)
}

// string string_val = 4;
inline bool GenericValue::_internal_has_string_val() const {
  return val_case() == kStringVal;
}
inline bool GenericValue::has_string_val() const {
  return _internal_has_string_val();
}
inline void GenericValue::set_has_string_val() {
  _impl_._oneof_case_[0] = kStringVal;
}
inline void GenericValue::clear_string_val() {
  if (_internal_has_string_val()) {
    _impl_.val_.string_val_.Destroy();
    clear_has_val();
  }
}
inline const std::string& GenericValue::string_val() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.GenericValue.string_val)
  return _internal_string_val();
}
template <typename ArgT0, typename... ArgT>
inline void GenericValue::set_string_val(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_string_val()) {
    clear_val();
    set_has_string_val();
    _impl_.val_.string_val_.InitDefault();
  }
  _impl_.val_.string_val_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.plan.GenericValue.string_val)
}
inline std::string* GenericValue::mutable_string_val() {
  std::string* _s = _internal_mutable_string_val();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.GenericValue.string_val)
  return _s;
}
inline const std::string& GenericValue::_internal_string_val() const {
  if (_internal_has_string_val()) {
    return _impl_.val_.string_val_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void GenericValue::_internal_set_string_val(const std::string& value) {
  if (!_internal_has_string_val()) {
    clear_val();
    set_has_string_val();
    _impl_.val_.string_val_.InitDefault();
  }
  _impl_.val_.string_val_.Set(value, GetArenaForAllocation());
}
inline std::string* GenericValue::_internal_mutable_string_val() {
  if (!_internal_has_string_val()) {
    clear_val();
    set_has_string_val();
    _impl_.val_.string_val_.InitDefault();
  }
  return _impl_.val_.string_val_.Mutable(      GetArenaForAllocation());
}
inline std::string* GenericValue::release_string_val() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.GenericValue.string_val)
  if (_internal_has_string_val()) {
    clear_has_val();
    return _impl_.val_.string_val_.Release();
  } else {
    return nullptr;
  }
}
inline void GenericValue::set_allocated_string_val(std::string* string_val) {
  if (has_val()) {
    clear_val();
  }
  if (string_val != nullptr) {
    set_has_string_val();
    _impl_.val_.string_val_.InitAllocated(string_val, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.GenericValue.string_val)
}

inline bool GenericValue::has_val() const {
  return val_case() != VAL_NOT_SET;
}
inline void GenericValue::clear_has_val() {
  _impl_._oneof_case_[0] = VAL_NOT_SET;
}
inline GenericValue::ValCase GenericValue::val_case() const {
  return GenericValue::ValCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// QueryInfo

// int64 topk = 1;
inline void QueryInfo::clear_topk() {
  _impl_.topk_ = int64_t{0};
}
inline int64_t QueryInfo::_internal_topk() const {
  return _impl_.topk_;
}
inline int64_t QueryInfo::topk() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.QueryInfo.topk)
  return _internal_topk();
}
inline void QueryInfo::_internal_set_topk(int64_t value) {
  
  _impl_.topk_ = value;
}
inline void QueryInfo::set_topk(int64_t value) {
  _internal_set_topk(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.QueryInfo.topk)
}

// string metric_type = 3;
inline void QueryInfo::clear_metric_type() {
  _impl_.metric_type_.ClearToEmpty();
}
inline const std::string& QueryInfo::metric_type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.QueryInfo.metric_type)
  return _internal_metric_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void QueryInfo::set_metric_type(ArgT0&& arg0, ArgT... args) {
 
 _impl_.metric_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.plan.QueryInfo.metric_type)
}
inline std::string* QueryInfo::mutable_metric_type() {
  std::string* _s = _internal_mutable_metric_type();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.QueryInfo.metric_type)
  return _s;
}
inline const std::string& QueryInfo::_internal_metric_type() const {
  return _impl_.metric_type_.Get();
}
inline void QueryInfo::_internal_set_metric_type(const std::string& value) {
  
  _impl_.metric_type_.Set(value, GetArenaForAllocation());
}
inline std::string* QueryInfo::_internal_mutable_metric_type() {
  
  return _impl_.metric_type_.Mutable(GetArenaForAllocation());
}
inline std::string* QueryInfo::release_metric_type() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.QueryInfo.metric_type)
  return _impl_.metric_type_.Release();
}
inline void QueryInfo::set_allocated_metric_type(std::string* metric_type) {
  if (metric_type != nullptr) {
    
  } else {
    
  }
  _impl_.metric_type_.SetAllocated(metric_type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.metric_type_.IsDefault()) {
    _impl_.metric_type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.QueryInfo.metric_type)
}

// string search_params = 4;
inline void QueryInfo::clear_search_params() {
  _impl_.search_params_.ClearToEmpty();
}
inline const std::string& QueryInfo::search_params() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.QueryInfo.search_params)
  return _internal_search_params();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void QueryInfo::set_search_params(ArgT0&& arg0, ArgT... args) {
 
 _impl_.search_params_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.plan.QueryInfo.search_params)
}
inline std::string* QueryInfo::mutable_search_params() {
  std::string* _s = _internal_mutable_search_params();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.QueryInfo.search_params)
  return _s;
}
inline const std::string& QueryInfo::_internal_search_params() const {
  return _impl_.search_params_.Get();
}
inline void QueryInfo::_internal_set_search_params(const std::string& value) {
  
  _impl_.search_params_.Set(value, GetArenaForAllocation());
}
inline std::string* QueryInfo::_internal_mutable_search_params() {
  
  return _impl_.search_params_.Mutable(GetArenaForAllocation());
}
inline std::string* QueryInfo::release_search_params() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.QueryInfo.search_params)
  return _impl_.search_params_.Release();
}
inline void QueryInfo::set_allocated_search_params(std::string* search_params) {
  if (search_params != nullptr) {
    
  } else {
    
  }
  _impl_.search_params_.SetAllocated(search_params, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.search_params_.IsDefault()) {
    _impl_.search_params_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.QueryInfo.search_params)
}

// int64 round_decimal = 5;
inline void QueryInfo::clear_round_decimal() {
  _impl_.round_decimal_ = int64_t{0};
}
inline int64_t QueryInfo::_internal_round_decimal() const {
  return _impl_.round_decimal_;
}
inline int64_t QueryInfo::round_decimal() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.QueryInfo.round_decimal)
  return _internal_round_decimal();
}
inline void QueryInfo::_internal_set_round_decimal(int64_t value) {
  
  _impl_.round_decimal_ = value;
}
inline void QueryInfo::set_round_decimal(int64_t value) {
  _internal_set_round_decimal(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.QueryInfo.round_decimal)
}

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

// ColumnInfo

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

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

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

// bool is_autoID = 4;
inline void ColumnInfo::clear_is_autoid() {
  _impl_.is_autoid_ = false;
}
inline bool ColumnInfo::_internal_is_autoid() const {
  return _impl_.is_autoid_;
}
inline bool ColumnInfo::is_autoid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.ColumnInfo.is_autoID)
  return _internal_is_autoid();
}
inline void ColumnInfo::_internal_set_is_autoid(bool value) {
  
  _impl_.is_autoid_ = value;
}
inline void ColumnInfo::set_is_autoid(bool value) {
  _internal_set_is_autoid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.ColumnInfo.is_autoID)
}

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

// ColumnExpr

// .milvus.proto.plan.ColumnInfo info = 1;
inline bool ColumnExpr::_internal_has_info() const {
  return this != internal_default_instance() && _impl_.info_ != nullptr;
}
inline bool ColumnExpr::has_info() const {
  return _internal_has_info();
}
inline void ColumnExpr::clear_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.info_ != nullptr) {
    delete _impl_.info_;
  }
  _impl_.info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& ColumnExpr::_internal_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& ColumnExpr::info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.ColumnExpr.info)
  return _internal_info();
}
inline void ColumnExpr::unsafe_arena_set_allocated_info(
    ::milvus::proto::plan::ColumnInfo* info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.info_);
  }
  _impl_.info_ = info;
  if (info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.ColumnExpr.info)
}
inline ::milvus::proto::plan::ColumnInfo* ColumnExpr::release_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.info_;
  _impl_.info_ = 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::plan::ColumnInfo* ColumnExpr::unsafe_arena_release_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.ColumnExpr.info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.info_;
  _impl_.info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* ColumnExpr::_internal_mutable_info() {
  
  if (_impl_.info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.info_ = p;
  }
  return _impl_.info_;
}
inline ::milvus::proto::plan::ColumnInfo* ColumnExpr::mutable_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.ColumnExpr.info)
  return _msg;
}
inline void ColumnExpr::set_allocated_info(::milvus::proto::plan::ColumnInfo* info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.info_;
  }
  if (info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(info);
    if (message_arena != submessage_arena) {
      info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.info_ = info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.ColumnExpr.info)
}

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

// ValueExpr

// .milvus.proto.plan.GenericValue value = 1;
inline bool ValueExpr::_internal_has_value() const {
  return this != internal_default_instance() && _impl_.value_ != nullptr;
}
inline bool ValueExpr::has_value() const {
  return _internal_has_value();
}
inline void ValueExpr::clear_value() {
  if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
    delete _impl_.value_;
  }
  _impl_.value_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& ValueExpr::_internal_value() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& ValueExpr::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.ValueExpr.value)
  return _internal_value();
}
inline void ValueExpr::unsafe_arena_set_allocated_value(
    ::milvus::proto::plan::GenericValue* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.ValueExpr.value)
}
inline ::milvus::proto::plan::GenericValue* ValueExpr::release_value() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.value_;
  _impl_.value_ = 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::plan::GenericValue* ValueExpr::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.ValueExpr.value)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* ValueExpr::_internal_mutable_value() {
  
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::milvus::proto::plan::GenericValue* ValueExpr::mutable_value() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.ValueExpr.value)
  return _msg;
}
inline void ValueExpr::set_allocated_value(::milvus::proto::plan::GenericValue* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.ValueExpr.value)
}

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

// UnaryRangeExpr

// .milvus.proto.plan.ColumnInfo column_info = 1;
inline bool UnaryRangeExpr::_internal_has_column_info() const {
  return this != internal_default_instance() && _impl_.column_info_ != nullptr;
}
inline bool UnaryRangeExpr::has_column_info() const {
  return _internal_has_column_info();
}
inline void UnaryRangeExpr::clear_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& UnaryRangeExpr::_internal_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& UnaryRangeExpr::column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.UnaryRangeExpr.column_info)
  return _internal_column_info();
}
inline void UnaryRangeExpr::unsafe_arena_set_allocated_column_info(
    ::milvus::proto::plan::ColumnInfo* column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.column_info_);
  }
  _impl_.column_info_ = column_info;
  if (column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.UnaryRangeExpr.column_info)
}
inline ::milvus::proto::plan::ColumnInfo* UnaryRangeExpr::release_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = 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::plan::ColumnInfo* UnaryRangeExpr::unsafe_arena_release_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.UnaryRangeExpr.column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* UnaryRangeExpr::_internal_mutable_column_info() {
  
  if (_impl_.column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.column_info_ = p;
  }
  return _impl_.column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* UnaryRangeExpr::mutable_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.UnaryRangeExpr.column_info)
  return _msg;
}
inline void UnaryRangeExpr::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.column_info_;
  }
  if (column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(column_info);
    if (message_arena != submessage_arena) {
      column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.column_info_ = column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.UnaryRangeExpr.column_info)
}

// .milvus.proto.plan.OpType op = 2;
inline void UnaryRangeExpr::clear_op() {
  _impl_.op_ = 0;
}
inline ::milvus::proto::plan::OpType UnaryRangeExpr::_internal_op() const {
  return static_cast< ::milvus::proto::plan::OpType >(_impl_.op_);
}
inline ::milvus::proto::plan::OpType UnaryRangeExpr::op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.UnaryRangeExpr.op)
  return _internal_op();
}
inline void UnaryRangeExpr::_internal_set_op(::milvus::proto::plan::OpType value) {
  
  _impl_.op_ = value;
}
inline void UnaryRangeExpr::set_op(::milvus::proto::plan::OpType value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.UnaryRangeExpr.op)
}

// .milvus.proto.plan.GenericValue value = 3;
inline bool UnaryRangeExpr::_internal_has_value() const {
  return this != internal_default_instance() && _impl_.value_ != nullptr;
}
inline bool UnaryRangeExpr::has_value() const {
  return _internal_has_value();
}
inline void UnaryRangeExpr::clear_value() {
  if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
    delete _impl_.value_;
  }
  _impl_.value_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& UnaryRangeExpr::_internal_value() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& UnaryRangeExpr::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.UnaryRangeExpr.value)
  return _internal_value();
}
inline void UnaryRangeExpr::unsafe_arena_set_allocated_value(
    ::milvus::proto::plan::GenericValue* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.UnaryRangeExpr.value)
}
inline ::milvus::proto::plan::GenericValue* UnaryRangeExpr::release_value() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.value_;
  _impl_.value_ = 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::plan::GenericValue* UnaryRangeExpr::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.UnaryRangeExpr.value)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* UnaryRangeExpr::_internal_mutable_value() {
  
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::milvus::proto::plan::GenericValue* UnaryRangeExpr::mutable_value() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.UnaryRangeExpr.value)
  return _msg;
}
inline void UnaryRangeExpr::set_allocated_value(::milvus::proto::plan::GenericValue* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.UnaryRangeExpr.value)
}

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

// BinaryRangeExpr

// .milvus.proto.plan.ColumnInfo column_info = 1;
inline bool BinaryRangeExpr::_internal_has_column_info() const {
  return this != internal_default_instance() && _impl_.column_info_ != nullptr;
}
inline bool BinaryRangeExpr::has_column_info() const {
  return _internal_has_column_info();
}
inline void BinaryRangeExpr::clear_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& BinaryRangeExpr::_internal_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& BinaryRangeExpr::column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryRangeExpr.column_info)
  return _internal_column_info();
}
inline void BinaryRangeExpr::unsafe_arena_set_allocated_column_info(
    ::milvus::proto::plan::ColumnInfo* column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.column_info_);
  }
  _impl_.column_info_ = column_info;
  if (column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryRangeExpr.column_info)
}
inline ::milvus::proto::plan::ColumnInfo* BinaryRangeExpr::release_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = 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::plan::ColumnInfo* BinaryRangeExpr::unsafe_arena_release_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryRangeExpr.column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* BinaryRangeExpr::_internal_mutable_column_info() {
  
  if (_impl_.column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.column_info_ = p;
  }
  return _impl_.column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* BinaryRangeExpr::mutable_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryRangeExpr.column_info)
  return _msg;
}
inline void BinaryRangeExpr::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.column_info_;
  }
  if (column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(column_info);
    if (message_arena != submessage_arena) {
      column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.column_info_ = column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryRangeExpr.column_info)
}

// bool lower_inclusive = 2;
inline void BinaryRangeExpr::clear_lower_inclusive() {
  _impl_.lower_inclusive_ = false;
}
inline bool BinaryRangeExpr::_internal_lower_inclusive() const {
  return _impl_.lower_inclusive_;
}
inline bool BinaryRangeExpr::lower_inclusive() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryRangeExpr.lower_inclusive)
  return _internal_lower_inclusive();
}
inline void BinaryRangeExpr::_internal_set_lower_inclusive(bool value) {
  
  _impl_.lower_inclusive_ = value;
}
inline void BinaryRangeExpr::set_lower_inclusive(bool value) {
  _internal_set_lower_inclusive(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryRangeExpr.lower_inclusive)
}

// bool upper_inclusive = 3;
inline void BinaryRangeExpr::clear_upper_inclusive() {
  _impl_.upper_inclusive_ = false;
}
inline bool BinaryRangeExpr::_internal_upper_inclusive() const {
  return _impl_.upper_inclusive_;
}
inline bool BinaryRangeExpr::upper_inclusive() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryRangeExpr.upper_inclusive)
  return _internal_upper_inclusive();
}
inline void BinaryRangeExpr::_internal_set_upper_inclusive(bool value) {
  
  _impl_.upper_inclusive_ = value;
}
inline void BinaryRangeExpr::set_upper_inclusive(bool value) {
  _internal_set_upper_inclusive(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryRangeExpr.upper_inclusive)
}

// .milvus.proto.plan.GenericValue lower_value = 4;
inline bool BinaryRangeExpr::_internal_has_lower_value() const {
  return this != internal_default_instance() && _impl_.lower_value_ != nullptr;
}
inline bool BinaryRangeExpr::has_lower_value() const {
  return _internal_has_lower_value();
}
inline void BinaryRangeExpr::clear_lower_value() {
  if (GetArenaForAllocation() == nullptr && _impl_.lower_value_ != nullptr) {
    delete _impl_.lower_value_;
  }
  _impl_.lower_value_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& BinaryRangeExpr::_internal_lower_value() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.lower_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& BinaryRangeExpr::lower_value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryRangeExpr.lower_value)
  return _internal_lower_value();
}
inline void BinaryRangeExpr::unsafe_arena_set_allocated_lower_value(
    ::milvus::proto::plan::GenericValue* lower_value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lower_value_);
  }
  _impl_.lower_value_ = lower_value;
  if (lower_value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryRangeExpr.lower_value)
}
inline ::milvus::proto::plan::GenericValue* BinaryRangeExpr::release_lower_value() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.lower_value_;
  _impl_.lower_value_ = 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::plan::GenericValue* BinaryRangeExpr::unsafe_arena_release_lower_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryRangeExpr.lower_value)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.lower_value_;
  _impl_.lower_value_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* BinaryRangeExpr::_internal_mutable_lower_value() {
  
  if (_impl_.lower_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.lower_value_ = p;
  }
  return _impl_.lower_value_;
}
inline ::milvus::proto::plan::GenericValue* BinaryRangeExpr::mutable_lower_value() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_lower_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryRangeExpr.lower_value)
  return _msg;
}
inline void BinaryRangeExpr::set_allocated_lower_value(::milvus::proto::plan::GenericValue* lower_value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lower_value_;
  }
  if (lower_value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lower_value);
    if (message_arena != submessage_arena) {
      lower_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lower_value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.lower_value_ = lower_value;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryRangeExpr.lower_value)
}

// .milvus.proto.plan.GenericValue upper_value = 5;
inline bool BinaryRangeExpr::_internal_has_upper_value() const {
  return this != internal_default_instance() && _impl_.upper_value_ != nullptr;
}
inline bool BinaryRangeExpr::has_upper_value() const {
  return _internal_has_upper_value();
}
inline void BinaryRangeExpr::clear_upper_value() {
  if (GetArenaForAllocation() == nullptr && _impl_.upper_value_ != nullptr) {
    delete _impl_.upper_value_;
  }
  _impl_.upper_value_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& BinaryRangeExpr::_internal_upper_value() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.upper_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& BinaryRangeExpr::upper_value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryRangeExpr.upper_value)
  return _internal_upper_value();
}
inline void BinaryRangeExpr::unsafe_arena_set_allocated_upper_value(
    ::milvus::proto::plan::GenericValue* upper_value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.upper_value_);
  }
  _impl_.upper_value_ = upper_value;
  if (upper_value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryRangeExpr.upper_value)
}
inline ::milvus::proto::plan::GenericValue* BinaryRangeExpr::release_upper_value() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.upper_value_;
  _impl_.upper_value_ = 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::plan::GenericValue* BinaryRangeExpr::unsafe_arena_release_upper_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryRangeExpr.upper_value)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.upper_value_;
  _impl_.upper_value_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* BinaryRangeExpr::_internal_mutable_upper_value() {
  
  if (_impl_.upper_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.upper_value_ = p;
  }
  return _impl_.upper_value_;
}
inline ::milvus::proto::plan::GenericValue* BinaryRangeExpr::mutable_upper_value() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_upper_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryRangeExpr.upper_value)
  return _msg;
}
inline void BinaryRangeExpr::set_allocated_upper_value(::milvus::proto::plan::GenericValue* upper_value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.upper_value_;
  }
  if (upper_value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(upper_value);
    if (message_arena != submessage_arena) {
      upper_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, upper_value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.upper_value_ = upper_value;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryRangeExpr.upper_value)
}

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

// CompareExpr

// .milvus.proto.plan.ColumnInfo left_column_info = 1;
inline bool CompareExpr::_internal_has_left_column_info() const {
  return this != internal_default_instance() && _impl_.left_column_info_ != nullptr;
}
inline bool CompareExpr::has_left_column_info() const {
  return _internal_has_left_column_info();
}
inline void CompareExpr::clear_left_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.left_column_info_ != nullptr) {
    delete _impl_.left_column_info_;
  }
  _impl_.left_column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& CompareExpr::_internal_left_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.left_column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& CompareExpr::left_column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.CompareExpr.left_column_info)
  return _internal_left_column_info();
}
inline void CompareExpr::unsafe_arena_set_allocated_left_column_info(
    ::milvus::proto::plan::ColumnInfo* left_column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.left_column_info_);
  }
  _impl_.left_column_info_ = left_column_info;
  if (left_column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.CompareExpr.left_column_info)
}
inline ::milvus::proto::plan::ColumnInfo* CompareExpr::release_left_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.left_column_info_;
  _impl_.left_column_info_ = 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::plan::ColumnInfo* CompareExpr::unsafe_arena_release_left_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.CompareExpr.left_column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.left_column_info_;
  _impl_.left_column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* CompareExpr::_internal_mutable_left_column_info() {
  
  if (_impl_.left_column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.left_column_info_ = p;
  }
  return _impl_.left_column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* CompareExpr::mutable_left_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_left_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.CompareExpr.left_column_info)
  return _msg;
}
inline void CompareExpr::set_allocated_left_column_info(::milvus::proto::plan::ColumnInfo* left_column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.left_column_info_;
  }
  if (left_column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(left_column_info);
    if (message_arena != submessage_arena) {
      left_column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, left_column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.left_column_info_ = left_column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.CompareExpr.left_column_info)
}

// .milvus.proto.plan.ColumnInfo right_column_info = 2;
inline bool CompareExpr::_internal_has_right_column_info() const {
  return this != internal_default_instance() && _impl_.right_column_info_ != nullptr;
}
inline bool CompareExpr::has_right_column_info() const {
  return _internal_has_right_column_info();
}
inline void CompareExpr::clear_right_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.right_column_info_ != nullptr) {
    delete _impl_.right_column_info_;
  }
  _impl_.right_column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& CompareExpr::_internal_right_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.right_column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& CompareExpr::right_column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.CompareExpr.right_column_info)
  return _internal_right_column_info();
}
inline void CompareExpr::unsafe_arena_set_allocated_right_column_info(
    ::milvus::proto::plan::ColumnInfo* right_column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.right_column_info_);
  }
  _impl_.right_column_info_ = right_column_info;
  if (right_column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.CompareExpr.right_column_info)
}
inline ::milvus::proto::plan::ColumnInfo* CompareExpr::release_right_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.right_column_info_;
  _impl_.right_column_info_ = 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::plan::ColumnInfo* CompareExpr::unsafe_arena_release_right_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.CompareExpr.right_column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.right_column_info_;
  _impl_.right_column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* CompareExpr::_internal_mutable_right_column_info() {
  
  if (_impl_.right_column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.right_column_info_ = p;
  }
  return _impl_.right_column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* CompareExpr::mutable_right_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_right_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.CompareExpr.right_column_info)
  return _msg;
}
inline void CompareExpr::set_allocated_right_column_info(::milvus::proto::plan::ColumnInfo* right_column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.right_column_info_;
  }
  if (right_column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(right_column_info);
    if (message_arena != submessage_arena) {
      right_column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, right_column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.right_column_info_ = right_column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.CompareExpr.right_column_info)
}

// .milvus.proto.plan.OpType op = 3;
inline void CompareExpr::clear_op() {
  _impl_.op_ = 0;
}
inline ::milvus::proto::plan::OpType CompareExpr::_internal_op() const {
  return static_cast< ::milvus::proto::plan::OpType >(_impl_.op_);
}
inline ::milvus::proto::plan::OpType CompareExpr::op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.CompareExpr.op)
  return _internal_op();
}
inline void CompareExpr::_internal_set_op(::milvus::proto::plan::OpType value) {
  
  _impl_.op_ = value;
}
inline void CompareExpr::set_op(::milvus::proto::plan::OpType value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.CompareExpr.op)
}

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

// TermExpr

// .milvus.proto.plan.ColumnInfo column_info = 1;
inline bool TermExpr::_internal_has_column_info() const {
  return this != internal_default_instance() && _impl_.column_info_ != nullptr;
}
inline bool TermExpr::has_column_info() const {
  return _internal_has_column_info();
}
inline void TermExpr::clear_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& TermExpr::_internal_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& TermExpr::column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.TermExpr.column_info)
  return _internal_column_info();
}
inline void TermExpr::unsafe_arena_set_allocated_column_info(
    ::milvus::proto::plan::ColumnInfo* column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.column_info_);
  }
  _impl_.column_info_ = column_info;
  if (column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.TermExpr.column_info)
}
inline ::milvus::proto::plan::ColumnInfo* TermExpr::release_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = 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::plan::ColumnInfo* TermExpr::unsafe_arena_release_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.TermExpr.column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* TermExpr::_internal_mutable_column_info() {
  
  if (_impl_.column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.column_info_ = p;
  }
  return _impl_.column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* TermExpr::mutable_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.TermExpr.column_info)
  return _msg;
}
inline void TermExpr::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.column_info_;
  }
  if (column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(column_info);
    if (message_arena != submessage_arena) {
      column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.column_info_ = column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.TermExpr.column_info)
}

// repeated .milvus.proto.plan.GenericValue values = 2;
inline int TermExpr::_internal_values_size() const {
  return _impl_.values_.size();
}
inline int TermExpr::values_size() const {
  return _internal_values_size();
}
inline void TermExpr::clear_values() {
  _impl_.values_.Clear();
}
inline ::milvus::proto::plan::GenericValue* TermExpr::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.TermExpr.values)
  return _impl_.values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::GenericValue >*
TermExpr::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.plan.TermExpr.values)
  return &_impl_.values_;
}
inline const ::milvus::proto::plan::GenericValue& TermExpr::_internal_values(int index) const {
  return _impl_.values_.Get(index);
}
inline const ::milvus::proto::plan::GenericValue& TermExpr::values(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.TermExpr.values)
  return _internal_values(index);
}
inline ::milvus::proto::plan::GenericValue* TermExpr::_internal_add_values() {
  return _impl_.values_.Add();
}
inline ::milvus::proto::plan::GenericValue* TermExpr::add_values() {
  ::milvus::proto::plan::GenericValue* _add = _internal_add_values();
  // @@protoc_insertion_point(field_add:milvus.proto.plan.TermExpr.values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::GenericValue >&
TermExpr::values() const {
  // @@protoc_insertion_point(field_list:milvus.proto.plan.TermExpr.values)
  return _impl_.values_;
}

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

// UnaryExpr

// .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
inline void UnaryExpr::clear_op() {
  _impl_.op_ = 0;
}
inline ::milvus::proto::plan::UnaryExpr_UnaryOp UnaryExpr::_internal_op() const {
  return static_cast< ::milvus::proto::plan::UnaryExpr_UnaryOp >(_impl_.op_);
}
inline ::milvus::proto::plan::UnaryExpr_UnaryOp UnaryExpr::op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.UnaryExpr.op)
  return _internal_op();
}
inline void UnaryExpr::_internal_set_op(::milvus::proto::plan::UnaryExpr_UnaryOp value) {
  
  _impl_.op_ = value;
}
inline void UnaryExpr::set_op(::milvus::proto::plan::UnaryExpr_UnaryOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.UnaryExpr.op)
}

// .milvus.proto.plan.Expr child = 2;
inline bool UnaryExpr::_internal_has_child() const {
  return this != internal_default_instance() && _impl_.child_ != nullptr;
}
inline bool UnaryExpr::has_child() const {
  return _internal_has_child();
}
inline void UnaryExpr::clear_child() {
  if (GetArenaForAllocation() == nullptr && _impl_.child_ != nullptr) {
    delete _impl_.child_;
  }
  _impl_.child_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& UnaryExpr::_internal_child() const {
  const ::milvus::proto::plan::Expr* p = _impl_.child_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& UnaryExpr::child() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.UnaryExpr.child)
  return _internal_child();
}
inline void UnaryExpr::unsafe_arena_set_allocated_child(
    ::milvus::proto::plan::Expr* child) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.child_);
  }
  _impl_.child_ = child;
  if (child) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.UnaryExpr.child)
}
inline ::milvus::proto::plan::Expr* UnaryExpr::release_child() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.child_;
  _impl_.child_ = 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::plan::Expr* UnaryExpr::unsafe_arena_release_child() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.UnaryExpr.child)
  
  ::milvus::proto::plan::Expr* temp = _impl_.child_;
  _impl_.child_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* UnaryExpr::_internal_mutable_child() {
  
  if (_impl_.child_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.child_ = p;
  }
  return _impl_.child_;
}
inline ::milvus::proto::plan::Expr* UnaryExpr::mutable_child() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_child();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.UnaryExpr.child)
  return _msg;
}
inline void UnaryExpr::set_allocated_child(::milvus::proto::plan::Expr* child) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.child_;
  }
  if (child) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(child);
    if (message_arena != submessage_arena) {
      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, child, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.child_ = child;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.UnaryExpr.child)
}

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

// BinaryExpr

// .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
inline void BinaryExpr::clear_op() {
  _impl_.op_ = 0;
}
inline ::milvus::proto::plan::BinaryExpr_BinaryOp BinaryExpr::_internal_op() const {
  return static_cast< ::milvus::proto::plan::BinaryExpr_BinaryOp >(_impl_.op_);
}
inline ::milvus::proto::plan::BinaryExpr_BinaryOp BinaryExpr::op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryExpr.op)
  return _internal_op();
}
inline void BinaryExpr::_internal_set_op(::milvus::proto::plan::BinaryExpr_BinaryOp value) {
  
  _impl_.op_ = value;
}
inline void BinaryExpr::set_op(::milvus::proto::plan::BinaryExpr_BinaryOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryExpr.op)
}

// .milvus.proto.plan.Expr left = 2;
inline bool BinaryExpr::_internal_has_left() const {
  return this != internal_default_instance() && _impl_.left_ != nullptr;
}
inline bool BinaryExpr::has_left() const {
  return _internal_has_left();
}
inline void BinaryExpr::clear_left() {
  if (GetArenaForAllocation() == nullptr && _impl_.left_ != nullptr) {
    delete _impl_.left_;
  }
  _impl_.left_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& BinaryExpr::_internal_left() const {
  const ::milvus::proto::plan::Expr* p = _impl_.left_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& BinaryExpr::left() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryExpr.left)
  return _internal_left();
}
inline void BinaryExpr::unsafe_arena_set_allocated_left(
    ::milvus::proto::plan::Expr* left) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.left_);
  }
  _impl_.left_ = left;
  if (left) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryExpr.left)
}
inline ::milvus::proto::plan::Expr* BinaryExpr::release_left() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.left_;
  _impl_.left_ = 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::plan::Expr* BinaryExpr::unsafe_arena_release_left() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryExpr.left)
  
  ::milvus::proto::plan::Expr* temp = _impl_.left_;
  _impl_.left_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* BinaryExpr::_internal_mutable_left() {
  
  if (_impl_.left_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.left_ = p;
  }
  return _impl_.left_;
}
inline ::milvus::proto::plan::Expr* BinaryExpr::mutable_left() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_left();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryExpr.left)
  return _msg;
}
inline void BinaryExpr::set_allocated_left(::milvus::proto::plan::Expr* left) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.left_;
  }
  if (left) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(left);
    if (message_arena != submessage_arena) {
      left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, left, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.left_ = left;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryExpr.left)
}

// .milvus.proto.plan.Expr right = 3;
inline bool BinaryExpr::_internal_has_right() const {
  return this != internal_default_instance() && _impl_.right_ != nullptr;
}
inline bool BinaryExpr::has_right() const {
  return _internal_has_right();
}
inline void BinaryExpr::clear_right() {
  if (GetArenaForAllocation() == nullptr && _impl_.right_ != nullptr) {
    delete _impl_.right_;
  }
  _impl_.right_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& BinaryExpr::_internal_right() const {
  const ::milvus::proto::plan::Expr* p = _impl_.right_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& BinaryExpr::right() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryExpr.right)
  return _internal_right();
}
inline void BinaryExpr::unsafe_arena_set_allocated_right(
    ::milvus::proto::plan::Expr* right) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.right_);
  }
  _impl_.right_ = right;
  if (right) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryExpr.right)
}
inline ::milvus::proto::plan::Expr* BinaryExpr::release_right() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.right_;
  _impl_.right_ = 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::plan::Expr* BinaryExpr::unsafe_arena_release_right() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryExpr.right)
  
  ::milvus::proto::plan::Expr* temp = _impl_.right_;
  _impl_.right_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* BinaryExpr::_internal_mutable_right() {
  
  if (_impl_.right_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.right_ = p;
  }
  return _impl_.right_;
}
inline ::milvus::proto::plan::Expr* BinaryExpr::mutable_right() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_right();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryExpr.right)
  return _msg;
}
inline void BinaryExpr::set_allocated_right(::milvus::proto::plan::Expr* right) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.right_;
  }
  if (right) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(right);
    if (message_arena != submessage_arena) {
      right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, right, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.right_ = right;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryExpr.right)
}

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

// BinaryArithOp

// .milvus.proto.plan.ColumnInfo column_info = 1;
inline bool BinaryArithOp::_internal_has_column_info() const {
  return this != internal_default_instance() && _impl_.column_info_ != nullptr;
}
inline bool BinaryArithOp::has_column_info() const {
  return _internal_has_column_info();
}
inline void BinaryArithOp::clear_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& BinaryArithOp::_internal_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& BinaryArithOp::column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOp.column_info)
  return _internal_column_info();
}
inline void BinaryArithOp::unsafe_arena_set_allocated_column_info(
    ::milvus::proto::plan::ColumnInfo* column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.column_info_);
  }
  _impl_.column_info_ = column_info;
  if (column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithOp.column_info)
}
inline ::milvus::proto::plan::ColumnInfo* BinaryArithOp::release_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = 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::plan::ColumnInfo* BinaryArithOp::unsafe_arena_release_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOp.column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* BinaryArithOp::_internal_mutable_column_info() {
  
  if (_impl_.column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.column_info_ = p;
  }
  return _impl_.column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* BinaryArithOp::mutable_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOp.column_info)
  return _msg;
}
inline void BinaryArithOp::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.column_info_;
  }
  if (column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(column_info);
    if (message_arena != submessage_arena) {
      column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.column_info_ = column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOp.column_info)
}

// .milvus.proto.plan.ArithOpType arith_op = 2;
inline void BinaryArithOp::clear_arith_op() {
  _impl_.arith_op_ = 0;
}
inline ::milvus::proto::plan::ArithOpType BinaryArithOp::_internal_arith_op() const {
  return static_cast< ::milvus::proto::plan::ArithOpType >(_impl_.arith_op_);
}
inline ::milvus::proto::plan::ArithOpType BinaryArithOp::arith_op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOp.arith_op)
  return _internal_arith_op();
}
inline void BinaryArithOp::_internal_set_arith_op(::milvus::proto::plan::ArithOpType value) {
  
  _impl_.arith_op_ = value;
}
inline void BinaryArithOp::set_arith_op(::milvus::proto::plan::ArithOpType value) {
  _internal_set_arith_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithOp.arith_op)
}

// .milvus.proto.plan.GenericValue right_operand = 3;
inline bool BinaryArithOp::_internal_has_right_operand() const {
  return this != internal_default_instance() && _impl_.right_operand_ != nullptr;
}
inline bool BinaryArithOp::has_right_operand() const {
  return _internal_has_right_operand();
}
inline void BinaryArithOp::clear_right_operand() {
  if (GetArenaForAllocation() == nullptr && _impl_.right_operand_ != nullptr) {
    delete _impl_.right_operand_;
  }
  _impl_.right_operand_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& BinaryArithOp::_internal_right_operand() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.right_operand_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& BinaryArithOp::right_operand() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOp.right_operand)
  return _internal_right_operand();
}
inline void BinaryArithOp::unsafe_arena_set_allocated_right_operand(
    ::milvus::proto::plan::GenericValue* right_operand) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.right_operand_);
  }
  _impl_.right_operand_ = right_operand;
  if (right_operand) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithOp.right_operand)
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOp::release_right_operand() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.right_operand_;
  _impl_.right_operand_ = 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::plan::GenericValue* BinaryArithOp::unsafe_arena_release_right_operand() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOp.right_operand)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.right_operand_;
  _impl_.right_operand_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOp::_internal_mutable_right_operand() {
  
  if (_impl_.right_operand_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.right_operand_ = p;
  }
  return _impl_.right_operand_;
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOp::mutable_right_operand() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_right_operand();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOp.right_operand)
  return _msg;
}
inline void BinaryArithOp::set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.right_operand_;
  }
  if (right_operand) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(right_operand);
    if (message_arena != submessage_arena) {
      right_operand = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, right_operand, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.right_operand_ = right_operand;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOp.right_operand)
}

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

// BinaryArithExpr

// .milvus.proto.plan.Expr left = 1;
inline bool BinaryArithExpr::_internal_has_left() const {
  return this != internal_default_instance() && _impl_.left_ != nullptr;
}
inline bool BinaryArithExpr::has_left() const {
  return _internal_has_left();
}
inline void BinaryArithExpr::clear_left() {
  if (GetArenaForAllocation() == nullptr && _impl_.left_ != nullptr) {
    delete _impl_.left_;
  }
  _impl_.left_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& BinaryArithExpr::_internal_left() const {
  const ::milvus::proto::plan::Expr* p = _impl_.left_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& BinaryArithExpr::left() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithExpr.left)
  return _internal_left();
}
inline void BinaryArithExpr::unsafe_arena_set_allocated_left(
    ::milvus::proto::plan::Expr* left) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.left_);
  }
  _impl_.left_ = left;
  if (left) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithExpr.left)
}
inline ::milvus::proto::plan::Expr* BinaryArithExpr::release_left() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.left_;
  _impl_.left_ = 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::plan::Expr* BinaryArithExpr::unsafe_arena_release_left() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithExpr.left)
  
  ::milvus::proto::plan::Expr* temp = _impl_.left_;
  _impl_.left_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* BinaryArithExpr::_internal_mutable_left() {
  
  if (_impl_.left_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.left_ = p;
  }
  return _impl_.left_;
}
inline ::milvus::proto::plan::Expr* BinaryArithExpr::mutable_left() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_left();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithExpr.left)
  return _msg;
}
inline void BinaryArithExpr::set_allocated_left(::milvus::proto::plan::Expr* left) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.left_;
  }
  if (left) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(left);
    if (message_arena != submessage_arena) {
      left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, left, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.left_ = left;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithExpr.left)
}

// .milvus.proto.plan.Expr right = 2;
inline bool BinaryArithExpr::_internal_has_right() const {
  return this != internal_default_instance() && _impl_.right_ != nullptr;
}
inline bool BinaryArithExpr::has_right() const {
  return _internal_has_right();
}
inline void BinaryArithExpr::clear_right() {
  if (GetArenaForAllocation() == nullptr && _impl_.right_ != nullptr) {
    delete _impl_.right_;
  }
  _impl_.right_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& BinaryArithExpr::_internal_right() const {
  const ::milvus::proto::plan::Expr* p = _impl_.right_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& BinaryArithExpr::right() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithExpr.right)
  return _internal_right();
}
inline void BinaryArithExpr::unsafe_arena_set_allocated_right(
    ::milvus::proto::plan::Expr* right) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.right_);
  }
  _impl_.right_ = right;
  if (right) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithExpr.right)
}
inline ::milvus::proto::plan::Expr* BinaryArithExpr::release_right() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.right_;
  _impl_.right_ = 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::plan::Expr* BinaryArithExpr::unsafe_arena_release_right() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithExpr.right)
  
  ::milvus::proto::plan::Expr* temp = _impl_.right_;
  _impl_.right_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* BinaryArithExpr::_internal_mutable_right() {
  
  if (_impl_.right_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.right_ = p;
  }
  return _impl_.right_;
}
inline ::milvus::proto::plan::Expr* BinaryArithExpr::mutable_right() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_right();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithExpr.right)
  return _msg;
}
inline void BinaryArithExpr::set_allocated_right(::milvus::proto::plan::Expr* right) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.right_;
  }
  if (right) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(right);
    if (message_arena != submessage_arena) {
      right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, right, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.right_ = right;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithExpr.right)
}

// .milvus.proto.plan.ArithOpType op = 3;
inline void BinaryArithExpr::clear_op() {
  _impl_.op_ = 0;
}
inline ::milvus::proto::plan::ArithOpType BinaryArithExpr::_internal_op() const {
  return static_cast< ::milvus::proto::plan::ArithOpType >(_impl_.op_);
}
inline ::milvus::proto::plan::ArithOpType BinaryArithExpr::op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithExpr.op)
  return _internal_op();
}
inline void BinaryArithExpr::_internal_set_op(::milvus::proto::plan::ArithOpType value) {
  
  _impl_.op_ = value;
}
inline void BinaryArithExpr::set_op(::milvus::proto::plan::ArithOpType value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithExpr.op)
}

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

// BinaryArithOpEvalRangeExpr

// .milvus.proto.plan.ColumnInfo column_info = 1;
inline bool BinaryArithOpEvalRangeExpr::_internal_has_column_info() const {
  return this != internal_default_instance() && _impl_.column_info_ != nullptr;
}
inline bool BinaryArithOpEvalRangeExpr::has_column_info() const {
  return _internal_has_column_info();
}
inline void BinaryArithOpEvalRangeExpr::clear_column_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
}
inline const ::milvus::proto::plan::ColumnInfo& BinaryArithOpEvalRangeExpr::_internal_column_info() const {
  const ::milvus::proto::plan::ColumnInfo* p = _impl_.column_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::ColumnInfo&>(
      ::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline const ::milvus::proto::plan::ColumnInfo& BinaryArithOpEvalRangeExpr::column_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info)
  return _internal_column_info();
}
inline void BinaryArithOpEvalRangeExpr::unsafe_arena_set_allocated_column_info(
    ::milvus::proto::plan::ColumnInfo* column_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.column_info_);
  }
  _impl_.column_info_ = column_info;
  if (column_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info)
}
inline ::milvus::proto::plan::ColumnInfo* BinaryArithOpEvalRangeExpr::release_column_info() {
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = 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::plan::ColumnInfo* BinaryArithOpEvalRangeExpr::unsafe_arena_release_column_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info)
  
  ::milvus::proto::plan::ColumnInfo* temp = _impl_.column_info_;
  _impl_.column_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::ColumnInfo* BinaryArithOpEvalRangeExpr::_internal_mutable_column_info() {
  
  if (_impl_.column_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaForAllocation());
    _impl_.column_info_ = p;
  }
  return _impl_.column_info_;
}
inline ::milvus::proto::plan::ColumnInfo* BinaryArithOpEvalRangeExpr::mutable_column_info() {
  ::milvus::proto::plan::ColumnInfo* _msg = _internal_mutable_column_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info)
  return _msg;
}
inline void BinaryArithOpEvalRangeExpr::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.column_info_;
  }
  if (column_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(column_info);
    if (message_arena != submessage_arena) {
      column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, column_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.column_info_ = column_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info)
}

// .milvus.proto.plan.ArithOpType arith_op = 2;
inline void BinaryArithOpEvalRangeExpr::clear_arith_op() {
  _impl_.arith_op_ = 0;
}
inline ::milvus::proto::plan::ArithOpType BinaryArithOpEvalRangeExpr::_internal_arith_op() const {
  return static_cast< ::milvus::proto::plan::ArithOpType >(_impl_.arith_op_);
}
inline ::milvus::proto::plan::ArithOpType BinaryArithOpEvalRangeExpr::arith_op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.arith_op)
  return _internal_arith_op();
}
inline void BinaryArithOpEvalRangeExpr::_internal_set_arith_op(::milvus::proto::plan::ArithOpType value) {
  
  _impl_.arith_op_ = value;
}
inline void BinaryArithOpEvalRangeExpr::set_arith_op(::milvus::proto::plan::ArithOpType value) {
  _internal_set_arith_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithOpEvalRangeExpr.arith_op)
}

// .milvus.proto.plan.GenericValue right_operand = 3;
inline bool BinaryArithOpEvalRangeExpr::_internal_has_right_operand() const {
  return this != internal_default_instance() && _impl_.right_operand_ != nullptr;
}
inline bool BinaryArithOpEvalRangeExpr::has_right_operand() const {
  return _internal_has_right_operand();
}
inline void BinaryArithOpEvalRangeExpr::clear_right_operand() {
  if (GetArenaForAllocation() == nullptr && _impl_.right_operand_ != nullptr) {
    delete _impl_.right_operand_;
  }
  _impl_.right_operand_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& BinaryArithOpEvalRangeExpr::_internal_right_operand() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.right_operand_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& BinaryArithOpEvalRangeExpr::right_operand() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand)
  return _internal_right_operand();
}
inline void BinaryArithOpEvalRangeExpr::unsafe_arena_set_allocated_right_operand(
    ::milvus::proto::plan::GenericValue* right_operand) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.right_operand_);
  }
  _impl_.right_operand_ = right_operand;
  if (right_operand) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand)
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::release_right_operand() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.right_operand_;
  _impl_.right_operand_ = 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::plan::GenericValue* BinaryArithOpEvalRangeExpr::unsafe_arena_release_right_operand() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.right_operand_;
  _impl_.right_operand_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::_internal_mutable_right_operand() {
  
  if (_impl_.right_operand_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.right_operand_ = p;
  }
  return _impl_.right_operand_;
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::mutable_right_operand() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_right_operand();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand)
  return _msg;
}
inline void BinaryArithOpEvalRangeExpr::set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.right_operand_;
  }
  if (right_operand) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(right_operand);
    if (message_arena != submessage_arena) {
      right_operand = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, right_operand, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.right_operand_ = right_operand;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand)
}

// .milvus.proto.plan.OpType op = 4;
inline void BinaryArithOpEvalRangeExpr::clear_op() {
  _impl_.op_ = 0;
}
inline ::milvus::proto::plan::OpType BinaryArithOpEvalRangeExpr::_internal_op() const {
  return static_cast< ::milvus::proto::plan::OpType >(_impl_.op_);
}
inline ::milvus::proto::plan::OpType BinaryArithOpEvalRangeExpr::op() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.op)
  return _internal_op();
}
inline void BinaryArithOpEvalRangeExpr::_internal_set_op(::milvus::proto::plan::OpType value) {
  
  _impl_.op_ = value;
}
inline void BinaryArithOpEvalRangeExpr::set_op(::milvus::proto::plan::OpType value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithOpEvalRangeExpr.op)
}

// .milvus.proto.plan.GenericValue value = 5;
inline bool BinaryArithOpEvalRangeExpr::_internal_has_value() const {
  return this != internal_default_instance() && _impl_.value_ != nullptr;
}
inline bool BinaryArithOpEvalRangeExpr::has_value() const {
  return _internal_has_value();
}
inline void BinaryArithOpEvalRangeExpr::clear_value() {
  if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
    delete _impl_.value_;
  }
  _impl_.value_ = nullptr;
}
inline const ::milvus::proto::plan::GenericValue& BinaryArithOpEvalRangeExpr::_internal_value() const {
  const ::milvus::proto::plan::GenericValue* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::GenericValue&>(
      ::milvus::proto::plan::_GenericValue_default_instance_);
}
inline const ::milvus::proto::plan::GenericValue& BinaryArithOpEvalRangeExpr::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value)
  return _internal_value();
}
inline void BinaryArithOpEvalRangeExpr::unsafe_arena_set_allocated_value(
    ::milvus::proto::plan::GenericValue* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value)
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::release_value() {
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.value_;
  _impl_.value_ = 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::plan::GenericValue* BinaryArithOpEvalRangeExpr::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value)
  
  ::milvus::proto::plan::GenericValue* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::_internal_mutable_value() {
  
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::mutable_value() {
  ::milvus::proto::plan::GenericValue* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value)
  return _msg;
}
inline void BinaryArithOpEvalRangeExpr::set_allocated_value(::milvus::proto::plan::GenericValue* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value)
}

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

// Expr

// .milvus.proto.plan.TermExpr term_expr = 1;
inline bool Expr::_internal_has_term_expr() const {
  return expr_case() == kTermExpr;
}
inline bool Expr::has_term_expr() const {
  return _internal_has_term_expr();
}
inline void Expr::set_has_term_expr() {
  _impl_._oneof_case_[0] = kTermExpr;
}
inline void Expr::clear_term_expr() {
  if (_internal_has_term_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.term_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::TermExpr* Expr::release_term_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.term_expr)
  if (_internal_has_term_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::TermExpr* temp = _impl_.expr_.term_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.term_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::TermExpr& Expr::_internal_term_expr() const {
  return _internal_has_term_expr()
      ? *_impl_.expr_.term_expr_
      : reinterpret_cast< ::milvus::proto::plan::TermExpr&>(::milvus::proto::plan::_TermExpr_default_instance_);
}
inline const ::milvus::proto::plan::TermExpr& Expr::term_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.term_expr)
  return _internal_term_expr();
}
inline ::milvus::proto::plan::TermExpr* Expr::unsafe_arena_release_term_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.term_expr)
  if (_internal_has_term_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::TermExpr* temp = _impl_.expr_.term_expr_;
    _impl_.expr_.term_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_term_expr(::milvus::proto::plan::TermExpr* term_expr) {
  clear_expr();
  if (term_expr) {
    set_has_term_expr();
    _impl_.expr_.term_expr_ = term_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.term_expr)
}
inline ::milvus::proto::plan::TermExpr* Expr::_internal_mutable_term_expr() {
  if (!_internal_has_term_expr()) {
    clear_expr();
    set_has_term_expr();
    _impl_.expr_.term_expr_ = CreateMaybeMessage< ::milvus::proto::plan::TermExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.term_expr_;
}
inline ::milvus::proto::plan::TermExpr* Expr::mutable_term_expr() {
  ::milvus::proto::plan::TermExpr* _msg = _internal_mutable_term_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.term_expr)
  return _msg;
}

// .milvus.proto.plan.UnaryExpr unary_expr = 2;
inline bool Expr::_internal_has_unary_expr() const {
  return expr_case() == kUnaryExpr;
}
inline bool Expr::has_unary_expr() const {
  return _internal_has_unary_expr();
}
inline void Expr::set_has_unary_expr() {
  _impl_._oneof_case_[0] = kUnaryExpr;
}
inline void Expr::clear_unary_expr() {
  if (_internal_has_unary_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.unary_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::UnaryExpr* Expr::release_unary_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.unary_expr)
  if (_internal_has_unary_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::UnaryExpr* temp = _impl_.expr_.unary_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.unary_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::UnaryExpr& Expr::_internal_unary_expr() const {
  return _internal_has_unary_expr()
      ? *_impl_.expr_.unary_expr_
      : reinterpret_cast< ::milvus::proto::plan::UnaryExpr&>(::milvus::proto::plan::_UnaryExpr_default_instance_);
}
inline const ::milvus::proto::plan::UnaryExpr& Expr::unary_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.unary_expr)
  return _internal_unary_expr();
}
inline ::milvus::proto::plan::UnaryExpr* Expr::unsafe_arena_release_unary_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.unary_expr)
  if (_internal_has_unary_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::UnaryExpr* temp = _impl_.expr_.unary_expr_;
    _impl_.expr_.unary_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_unary_expr(::milvus::proto::plan::UnaryExpr* unary_expr) {
  clear_expr();
  if (unary_expr) {
    set_has_unary_expr();
    _impl_.expr_.unary_expr_ = unary_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.unary_expr)
}
inline ::milvus::proto::plan::UnaryExpr* Expr::_internal_mutable_unary_expr() {
  if (!_internal_has_unary_expr()) {
    clear_expr();
    set_has_unary_expr();
    _impl_.expr_.unary_expr_ = CreateMaybeMessage< ::milvus::proto::plan::UnaryExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.unary_expr_;
}
inline ::milvus::proto::plan::UnaryExpr* Expr::mutable_unary_expr() {
  ::milvus::proto::plan::UnaryExpr* _msg = _internal_mutable_unary_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.unary_expr)
  return _msg;
}

// .milvus.proto.plan.BinaryExpr binary_expr = 3;
inline bool Expr::_internal_has_binary_expr() const {
  return expr_case() == kBinaryExpr;
}
inline bool Expr::has_binary_expr() const {
  return _internal_has_binary_expr();
}
inline void Expr::set_has_binary_expr() {
  _impl_._oneof_case_[0] = kBinaryExpr;
}
inline void Expr::clear_binary_expr() {
  if (_internal_has_binary_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.binary_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::BinaryExpr* Expr::release_binary_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.binary_expr)
  if (_internal_has_binary_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryExpr* temp = _impl_.expr_.binary_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.binary_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::BinaryExpr& Expr::_internal_binary_expr() const {
  return _internal_has_binary_expr()
      ? *_impl_.expr_.binary_expr_
      : reinterpret_cast< ::milvus::proto::plan::BinaryExpr&>(::milvus::proto::plan::_BinaryExpr_default_instance_);
}
inline const ::milvus::proto::plan::BinaryExpr& Expr::binary_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.binary_expr)
  return _internal_binary_expr();
}
inline ::milvus::proto::plan::BinaryExpr* Expr::unsafe_arena_release_binary_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.binary_expr)
  if (_internal_has_binary_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryExpr* temp = _impl_.expr_.binary_expr_;
    _impl_.expr_.binary_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_binary_expr(::milvus::proto::plan::BinaryExpr* binary_expr) {
  clear_expr();
  if (binary_expr) {
    set_has_binary_expr();
    _impl_.expr_.binary_expr_ = binary_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.binary_expr)
}
inline ::milvus::proto::plan::BinaryExpr* Expr::_internal_mutable_binary_expr() {
  if (!_internal_has_binary_expr()) {
    clear_expr();
    set_has_binary_expr();
    _impl_.expr_.binary_expr_ = CreateMaybeMessage< ::milvus::proto::plan::BinaryExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.binary_expr_;
}
inline ::milvus::proto::plan::BinaryExpr* Expr::mutable_binary_expr() {
  ::milvus::proto::plan::BinaryExpr* _msg = _internal_mutable_binary_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.binary_expr)
  return _msg;
}

// .milvus.proto.plan.CompareExpr compare_expr = 4;
inline bool Expr::_internal_has_compare_expr() const {
  return expr_case() == kCompareExpr;
}
inline bool Expr::has_compare_expr() const {
  return _internal_has_compare_expr();
}
inline void Expr::set_has_compare_expr() {
  _impl_._oneof_case_[0] = kCompareExpr;
}
inline void Expr::clear_compare_expr() {
  if (_internal_has_compare_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.compare_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::CompareExpr* Expr::release_compare_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.compare_expr)
  if (_internal_has_compare_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::CompareExpr* temp = _impl_.expr_.compare_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.compare_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::CompareExpr& Expr::_internal_compare_expr() const {
  return _internal_has_compare_expr()
      ? *_impl_.expr_.compare_expr_
      : reinterpret_cast< ::milvus::proto::plan::CompareExpr&>(::milvus::proto::plan::_CompareExpr_default_instance_);
}
inline const ::milvus::proto::plan::CompareExpr& Expr::compare_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.compare_expr)
  return _internal_compare_expr();
}
inline ::milvus::proto::plan::CompareExpr* Expr::unsafe_arena_release_compare_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.compare_expr)
  if (_internal_has_compare_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::CompareExpr* temp = _impl_.expr_.compare_expr_;
    _impl_.expr_.compare_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_compare_expr(::milvus::proto::plan::CompareExpr* compare_expr) {
  clear_expr();
  if (compare_expr) {
    set_has_compare_expr();
    _impl_.expr_.compare_expr_ = compare_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.compare_expr)
}
inline ::milvus::proto::plan::CompareExpr* Expr::_internal_mutable_compare_expr() {
  if (!_internal_has_compare_expr()) {
    clear_expr();
    set_has_compare_expr();
    _impl_.expr_.compare_expr_ = CreateMaybeMessage< ::milvus::proto::plan::CompareExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.compare_expr_;
}
inline ::milvus::proto::plan::CompareExpr* Expr::mutable_compare_expr() {
  ::milvus::proto::plan::CompareExpr* _msg = _internal_mutable_compare_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.compare_expr)
  return _msg;
}

// .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
inline bool Expr::_internal_has_unary_range_expr() const {
  return expr_case() == kUnaryRangeExpr;
}
inline bool Expr::has_unary_range_expr() const {
  return _internal_has_unary_range_expr();
}
inline void Expr::set_has_unary_range_expr() {
  _impl_._oneof_case_[0] = kUnaryRangeExpr;
}
inline void Expr::clear_unary_range_expr() {
  if (_internal_has_unary_range_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.unary_range_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::UnaryRangeExpr* Expr::release_unary_range_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.unary_range_expr)
  if (_internal_has_unary_range_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::UnaryRangeExpr* temp = _impl_.expr_.unary_range_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.unary_range_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::UnaryRangeExpr& Expr::_internal_unary_range_expr() const {
  return _internal_has_unary_range_expr()
      ? *_impl_.expr_.unary_range_expr_
      : reinterpret_cast< ::milvus::proto::plan::UnaryRangeExpr&>(::milvus::proto::plan::_UnaryRangeExpr_default_instance_);
}
inline const ::milvus::proto::plan::UnaryRangeExpr& Expr::unary_range_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.unary_range_expr)
  return _internal_unary_range_expr();
}
inline ::milvus::proto::plan::UnaryRangeExpr* Expr::unsafe_arena_release_unary_range_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.unary_range_expr)
  if (_internal_has_unary_range_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::UnaryRangeExpr* temp = _impl_.expr_.unary_range_expr_;
    _impl_.expr_.unary_range_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_unary_range_expr(::milvus::proto::plan::UnaryRangeExpr* unary_range_expr) {
  clear_expr();
  if (unary_range_expr) {
    set_has_unary_range_expr();
    _impl_.expr_.unary_range_expr_ = unary_range_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.unary_range_expr)
}
inline ::milvus::proto::plan::UnaryRangeExpr* Expr::_internal_mutable_unary_range_expr() {
  if (!_internal_has_unary_range_expr()) {
    clear_expr();
    set_has_unary_range_expr();
    _impl_.expr_.unary_range_expr_ = CreateMaybeMessage< ::milvus::proto::plan::UnaryRangeExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.unary_range_expr_;
}
inline ::milvus::proto::plan::UnaryRangeExpr* Expr::mutable_unary_range_expr() {
  ::milvus::proto::plan::UnaryRangeExpr* _msg = _internal_mutable_unary_range_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.unary_range_expr)
  return _msg;
}

// .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
inline bool Expr::_internal_has_binary_range_expr() const {
  return expr_case() == kBinaryRangeExpr;
}
inline bool Expr::has_binary_range_expr() const {
  return _internal_has_binary_range_expr();
}
inline void Expr::set_has_binary_range_expr() {
  _impl_._oneof_case_[0] = kBinaryRangeExpr;
}
inline void Expr::clear_binary_range_expr() {
  if (_internal_has_binary_range_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.binary_range_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::BinaryRangeExpr* Expr::release_binary_range_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.binary_range_expr)
  if (_internal_has_binary_range_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryRangeExpr* temp = _impl_.expr_.binary_range_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.binary_range_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::BinaryRangeExpr& Expr::_internal_binary_range_expr() const {
  return _internal_has_binary_range_expr()
      ? *_impl_.expr_.binary_range_expr_
      : reinterpret_cast< ::milvus::proto::plan::BinaryRangeExpr&>(::milvus::proto::plan::_BinaryRangeExpr_default_instance_);
}
inline const ::milvus::proto::plan::BinaryRangeExpr& Expr::binary_range_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.binary_range_expr)
  return _internal_binary_range_expr();
}
inline ::milvus::proto::plan::BinaryRangeExpr* Expr::unsafe_arena_release_binary_range_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.binary_range_expr)
  if (_internal_has_binary_range_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryRangeExpr* temp = _impl_.expr_.binary_range_expr_;
    _impl_.expr_.binary_range_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_binary_range_expr(::milvus::proto::plan::BinaryRangeExpr* binary_range_expr) {
  clear_expr();
  if (binary_range_expr) {
    set_has_binary_range_expr();
    _impl_.expr_.binary_range_expr_ = binary_range_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.binary_range_expr)
}
inline ::milvus::proto::plan::BinaryRangeExpr* Expr::_internal_mutable_binary_range_expr() {
  if (!_internal_has_binary_range_expr()) {
    clear_expr();
    set_has_binary_range_expr();
    _impl_.expr_.binary_range_expr_ = CreateMaybeMessage< ::milvus::proto::plan::BinaryRangeExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.binary_range_expr_;
}
inline ::milvus::proto::plan::BinaryRangeExpr* Expr::mutable_binary_range_expr() {
  ::milvus::proto::plan::BinaryRangeExpr* _msg = _internal_mutable_binary_range_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.binary_range_expr)
  return _msg;
}

// .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7;
inline bool Expr::_internal_has_binary_arith_op_eval_range_expr() const {
  return expr_case() == kBinaryArithOpEvalRangeExpr;
}
inline bool Expr::has_binary_arith_op_eval_range_expr() const {
  return _internal_has_binary_arith_op_eval_range_expr();
}
inline void Expr::set_has_binary_arith_op_eval_range_expr() {
  _impl_._oneof_case_[0] = kBinaryArithOpEvalRangeExpr;
}
inline void Expr::clear_binary_arith_op_eval_range_expr() {
  if (_internal_has_binary_arith_op_eval_range_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.binary_arith_op_eval_range_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Expr::release_binary_arith_op_eval_range_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr)
  if (_internal_has_binary_arith_op_eval_range_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* temp = _impl_.expr_.binary_arith_op_eval_range_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.binary_arith_op_eval_range_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& Expr::_internal_binary_arith_op_eval_range_expr() const {
  return _internal_has_binary_arith_op_eval_range_expr()
      ? *_impl_.expr_.binary_arith_op_eval_range_expr_
      : reinterpret_cast< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr&>(::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_);
}
inline const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& Expr::binary_arith_op_eval_range_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr)
  return _internal_binary_arith_op_eval_range_expr();
}
inline ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Expr::unsafe_arena_release_binary_arith_op_eval_range_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr)
  if (_internal_has_binary_arith_op_eval_range_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* temp = _impl_.expr_.binary_arith_op_eval_range_expr_;
    _impl_.expr_.binary_arith_op_eval_range_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_binary_arith_op_eval_range_expr(::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr) {
  clear_expr();
  if (binary_arith_op_eval_range_expr) {
    set_has_binary_arith_op_eval_range_expr();
    _impl_.expr_.binary_arith_op_eval_range_expr_ = binary_arith_op_eval_range_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr)
}
inline ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Expr::_internal_mutable_binary_arith_op_eval_range_expr() {
  if (!_internal_has_binary_arith_op_eval_range_expr()) {
    clear_expr();
    set_has_binary_arith_op_eval_range_expr();
    _impl_.expr_.binary_arith_op_eval_range_expr_ = CreateMaybeMessage< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.binary_arith_op_eval_range_expr_;
}
inline ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Expr::mutable_binary_arith_op_eval_range_expr() {
  ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* _msg = _internal_mutable_binary_arith_op_eval_range_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr)
  return _msg;
}

// .milvus.proto.plan.BinaryArithExpr binary_arith_expr = 8;
inline bool Expr::_internal_has_binary_arith_expr() const {
  return expr_case() == kBinaryArithExpr;
}
inline bool Expr::has_binary_arith_expr() const {
  return _internal_has_binary_arith_expr();
}
inline void Expr::set_has_binary_arith_expr() {
  _impl_._oneof_case_[0] = kBinaryArithExpr;
}
inline void Expr::clear_binary_arith_expr() {
  if (_internal_has_binary_arith_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.binary_arith_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::BinaryArithExpr* Expr::release_binary_arith_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.binary_arith_expr)
  if (_internal_has_binary_arith_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryArithExpr* temp = _impl_.expr_.binary_arith_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.binary_arith_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::BinaryArithExpr& Expr::_internal_binary_arith_expr() const {
  return _internal_has_binary_arith_expr()
      ? *_impl_.expr_.binary_arith_expr_
      : reinterpret_cast< ::milvus::proto::plan::BinaryArithExpr&>(::milvus::proto::plan::_BinaryArithExpr_default_instance_);
}
inline const ::milvus::proto::plan::BinaryArithExpr& Expr::binary_arith_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.binary_arith_expr)
  return _internal_binary_arith_expr();
}
inline ::milvus::proto::plan::BinaryArithExpr* Expr::unsafe_arena_release_binary_arith_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.binary_arith_expr)
  if (_internal_has_binary_arith_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::BinaryArithExpr* temp = _impl_.expr_.binary_arith_expr_;
    _impl_.expr_.binary_arith_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_binary_arith_expr(::milvus::proto::plan::BinaryArithExpr* binary_arith_expr) {
  clear_expr();
  if (binary_arith_expr) {
    set_has_binary_arith_expr();
    _impl_.expr_.binary_arith_expr_ = binary_arith_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.binary_arith_expr)
}
inline ::milvus::proto::plan::BinaryArithExpr* Expr::_internal_mutable_binary_arith_expr() {
  if (!_internal_has_binary_arith_expr()) {
    clear_expr();
    set_has_binary_arith_expr();
    _impl_.expr_.binary_arith_expr_ = CreateMaybeMessage< ::milvus::proto::plan::BinaryArithExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.binary_arith_expr_;
}
inline ::milvus::proto::plan::BinaryArithExpr* Expr::mutable_binary_arith_expr() {
  ::milvus::proto::plan::BinaryArithExpr* _msg = _internal_mutable_binary_arith_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.binary_arith_expr)
  return _msg;
}

// .milvus.proto.plan.ValueExpr value_expr = 9;
inline bool Expr::_internal_has_value_expr() const {
  return expr_case() == kValueExpr;
}
inline bool Expr::has_value_expr() const {
  return _internal_has_value_expr();
}
inline void Expr::set_has_value_expr() {
  _impl_._oneof_case_[0] = kValueExpr;
}
inline void Expr::clear_value_expr() {
  if (_internal_has_value_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.value_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::ValueExpr* Expr::release_value_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.value_expr)
  if (_internal_has_value_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::ValueExpr* temp = _impl_.expr_.value_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::ValueExpr& Expr::_internal_value_expr() const {
  return _internal_has_value_expr()
      ? *_impl_.expr_.value_expr_
      : reinterpret_cast< ::milvus::proto::plan::ValueExpr&>(::milvus::proto::plan::_ValueExpr_default_instance_);
}
inline const ::milvus::proto::plan::ValueExpr& Expr::value_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.value_expr)
  return _internal_value_expr();
}
inline ::milvus::proto::plan::ValueExpr* Expr::unsafe_arena_release_value_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.value_expr)
  if (_internal_has_value_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::ValueExpr* temp = _impl_.expr_.value_expr_;
    _impl_.expr_.value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_value_expr(::milvus::proto::plan::ValueExpr* value_expr) {
  clear_expr();
  if (value_expr) {
    set_has_value_expr();
    _impl_.expr_.value_expr_ = value_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.value_expr)
}
inline ::milvus::proto::plan::ValueExpr* Expr::_internal_mutable_value_expr() {
  if (!_internal_has_value_expr()) {
    clear_expr();
    set_has_value_expr();
    _impl_.expr_.value_expr_ = CreateMaybeMessage< ::milvus::proto::plan::ValueExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.value_expr_;
}
inline ::milvus::proto::plan::ValueExpr* Expr::mutable_value_expr() {
  ::milvus::proto::plan::ValueExpr* _msg = _internal_mutable_value_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.value_expr)
  return _msg;
}

// .milvus.proto.plan.ColumnExpr column_expr = 10;
inline bool Expr::_internal_has_column_expr() const {
  return expr_case() == kColumnExpr;
}
inline bool Expr::has_column_expr() const {
  return _internal_has_column_expr();
}
inline void Expr::set_has_column_expr() {
  _impl_._oneof_case_[0] = kColumnExpr;
}
inline void Expr::clear_column_expr() {
  if (_internal_has_column_expr()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.expr_.column_expr_;
    }
    clear_has_expr();
  }
}
inline ::milvus::proto::plan::ColumnExpr* Expr::release_column_expr() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.column_expr)
  if (_internal_has_column_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::ColumnExpr* temp = _impl_.expr_.column_expr_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.expr_.column_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::ColumnExpr& Expr::_internal_column_expr() const {
  return _internal_has_column_expr()
      ? *_impl_.expr_.column_expr_
      : reinterpret_cast< ::milvus::proto::plan::ColumnExpr&>(::milvus::proto::plan::_ColumnExpr_default_instance_);
}
inline const ::milvus::proto::plan::ColumnExpr& Expr::column_expr() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.column_expr)
  return _internal_column_expr();
}
inline ::milvus::proto::plan::ColumnExpr* Expr::unsafe_arena_release_column_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.Expr.column_expr)
  if (_internal_has_column_expr()) {
    clear_has_expr();
    ::milvus::proto::plan::ColumnExpr* temp = _impl_.expr_.column_expr_;
    _impl_.expr_.column_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Expr::unsafe_arena_set_allocated_column_expr(::milvus::proto::plan::ColumnExpr* column_expr) {
  clear_expr();
  if (column_expr) {
    set_has_column_expr();
    _impl_.expr_.column_expr_ = column_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.Expr.column_expr)
}
inline ::milvus::proto::plan::ColumnExpr* Expr::_internal_mutable_column_expr() {
  if (!_internal_has_column_expr()) {
    clear_expr();
    set_has_column_expr();
    _impl_.expr_.column_expr_ = CreateMaybeMessage< ::milvus::proto::plan::ColumnExpr >(GetArenaForAllocation());
  }
  return _impl_.expr_.column_expr_;
}
inline ::milvus::proto::plan::ColumnExpr* Expr::mutable_column_expr() {
  ::milvus::proto::plan::ColumnExpr* _msg = _internal_mutable_column_expr();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.column_expr)
  return _msg;
}

inline bool Expr::has_expr() const {
  return expr_case() != EXPR_NOT_SET;
}
inline void Expr::clear_has_expr() {
  _impl_._oneof_case_[0] = EXPR_NOT_SET;
}
inline Expr::ExprCase Expr::expr_case() const {
  return Expr::ExprCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// VectorANNS

// bool is_binary = 1;
inline void VectorANNS::clear_is_binary() {
  _impl_.is_binary_ = false;
}
inline bool VectorANNS::_internal_is_binary() const {
  return _impl_.is_binary_;
}
inline bool VectorANNS::is_binary() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.VectorANNS.is_binary)
  return _internal_is_binary();
}
inline void VectorANNS::_internal_set_is_binary(bool value) {
  
  _impl_.is_binary_ = value;
}
inline void VectorANNS::set_is_binary(bool value) {
  _internal_set_is_binary(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.VectorANNS.is_binary)
}

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

// .milvus.proto.plan.Expr predicates = 3;
inline bool VectorANNS::_internal_has_predicates() const {
  return this != internal_default_instance() && _impl_.predicates_ != nullptr;
}
inline bool VectorANNS::has_predicates() const {
  return _internal_has_predicates();
}
inline void VectorANNS::clear_predicates() {
  if (GetArenaForAllocation() == nullptr && _impl_.predicates_ != nullptr) {
    delete _impl_.predicates_;
  }
  _impl_.predicates_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& VectorANNS::_internal_predicates() const {
  const ::milvus::proto::plan::Expr* p = _impl_.predicates_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& VectorANNS::predicates() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.VectorANNS.predicates)
  return _internal_predicates();
}
inline void VectorANNS::unsafe_arena_set_allocated_predicates(
    ::milvus::proto::plan::Expr* predicates) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.predicates_);
  }
  _impl_.predicates_ = predicates;
  if (predicates) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.VectorANNS.predicates)
}
inline ::milvus::proto::plan::Expr* VectorANNS::release_predicates() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.predicates_;
  _impl_.predicates_ = 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::plan::Expr* VectorANNS::unsafe_arena_release_predicates() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.VectorANNS.predicates)
  
  ::milvus::proto::plan::Expr* temp = _impl_.predicates_;
  _impl_.predicates_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* VectorANNS::_internal_mutable_predicates() {
  
  if (_impl_.predicates_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.predicates_ = p;
  }
  return _impl_.predicates_;
}
inline ::milvus::proto::plan::Expr* VectorANNS::mutable_predicates() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_predicates();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.VectorANNS.predicates)
  return _msg;
}
inline void VectorANNS::set_allocated_predicates(::milvus::proto::plan::Expr* predicates) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.predicates_;
  }
  if (predicates) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(predicates);
    if (message_arena != submessage_arena) {
      predicates = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, predicates, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.predicates_ = predicates;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.VectorANNS.predicates)
}

// .milvus.proto.plan.QueryInfo query_info = 4;
inline bool VectorANNS::_internal_has_query_info() const {
  return this != internal_default_instance() && _impl_.query_info_ != nullptr;
}
inline bool VectorANNS::has_query_info() const {
  return _internal_has_query_info();
}
inline void VectorANNS::clear_query_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.query_info_ != nullptr) {
    delete _impl_.query_info_;
  }
  _impl_.query_info_ = nullptr;
}
inline const ::milvus::proto::plan::QueryInfo& VectorANNS::_internal_query_info() const {
  const ::milvus::proto::plan::QueryInfo* p = _impl_.query_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::QueryInfo&>(
      ::milvus::proto::plan::_QueryInfo_default_instance_);
}
inline const ::milvus::proto::plan::QueryInfo& VectorANNS::query_info() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.VectorANNS.query_info)
  return _internal_query_info();
}
inline void VectorANNS::unsafe_arena_set_allocated_query_info(
    ::milvus::proto::plan::QueryInfo* query_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_info_);
  }
  _impl_.query_info_ = query_info;
  if (query_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.VectorANNS.query_info)
}
inline ::milvus::proto::plan::QueryInfo* VectorANNS::release_query_info() {
  
  ::milvus::proto::plan::QueryInfo* temp = _impl_.query_info_;
  _impl_.query_info_ = 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::plan::QueryInfo* VectorANNS::unsafe_arena_release_query_info() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.VectorANNS.query_info)
  
  ::milvus::proto::plan::QueryInfo* temp = _impl_.query_info_;
  _impl_.query_info_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::QueryInfo* VectorANNS::_internal_mutable_query_info() {
  
  if (_impl_.query_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::QueryInfo>(GetArenaForAllocation());
    _impl_.query_info_ = p;
  }
  return _impl_.query_info_;
}
inline ::milvus::proto::plan::QueryInfo* VectorANNS::mutable_query_info() {
  ::milvus::proto::plan::QueryInfo* _msg = _internal_mutable_query_info();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.VectorANNS.query_info)
  return _msg;
}
inline void VectorANNS::set_allocated_query_info(::milvus::proto::plan::QueryInfo* query_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.query_info_;
  }
  if (query_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query_info);
    if (message_arena != submessage_arena) {
      query_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.query_info_ = query_info;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.VectorANNS.query_info)
}

// string placeholder_tag = 5;
inline void VectorANNS::clear_placeholder_tag() {
  _impl_.placeholder_tag_.ClearToEmpty();
}
inline const std::string& VectorANNS::placeholder_tag() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.VectorANNS.placeholder_tag)
  return _internal_placeholder_tag();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VectorANNS::set_placeholder_tag(ArgT0&& arg0, ArgT... args) {
 
 _impl_.placeholder_tag_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.plan.VectorANNS.placeholder_tag)
}
inline std::string* VectorANNS::mutable_placeholder_tag() {
  std::string* _s = _internal_mutable_placeholder_tag();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.VectorANNS.placeholder_tag)
  return _s;
}
inline const std::string& VectorANNS::_internal_placeholder_tag() const {
  return _impl_.placeholder_tag_.Get();
}
inline void VectorANNS::_internal_set_placeholder_tag(const std::string& value) {
  
  _impl_.placeholder_tag_.Set(value, GetArenaForAllocation());
}
inline std::string* VectorANNS::_internal_mutable_placeholder_tag() {
  
  return _impl_.placeholder_tag_.Mutable(GetArenaForAllocation());
}
inline std::string* VectorANNS::release_placeholder_tag() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.VectorANNS.placeholder_tag)
  return _impl_.placeholder_tag_.Release();
}
inline void VectorANNS::set_allocated_placeholder_tag(std::string* placeholder_tag) {
  if (placeholder_tag != nullptr) {
    
  } else {
    
  }
  _impl_.placeholder_tag_.SetAllocated(placeholder_tag, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.placeholder_tag_.IsDefault()) {
    _impl_.placeholder_tag_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.VectorANNS.placeholder_tag)
}

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

// QueryPlanNode

// .milvus.proto.plan.Expr predicates = 1;
inline bool QueryPlanNode::_internal_has_predicates() const {
  return this != internal_default_instance() && _impl_.predicates_ != nullptr;
}
inline bool QueryPlanNode::has_predicates() const {
  return _internal_has_predicates();
}
inline void QueryPlanNode::clear_predicates() {
  if (GetArenaForAllocation() == nullptr && _impl_.predicates_ != nullptr) {
    delete _impl_.predicates_;
  }
  _impl_.predicates_ = nullptr;
}
inline const ::milvus::proto::plan::Expr& QueryPlanNode::_internal_predicates() const {
  const ::milvus::proto::plan::Expr* p = _impl_.predicates_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::plan::Expr&>(
      ::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& QueryPlanNode::predicates() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.QueryPlanNode.predicates)
  return _internal_predicates();
}
inline void QueryPlanNode::unsafe_arena_set_allocated_predicates(
    ::milvus::proto::plan::Expr* predicates) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.predicates_);
  }
  _impl_.predicates_ = predicates;
  if (predicates) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.QueryPlanNode.predicates)
}
inline ::milvus::proto::plan::Expr* QueryPlanNode::release_predicates() {
  
  ::milvus::proto::plan::Expr* temp = _impl_.predicates_;
  _impl_.predicates_ = 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::plan::Expr* QueryPlanNode::unsafe_arena_release_predicates() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.QueryPlanNode.predicates)
  
  ::milvus::proto::plan::Expr* temp = _impl_.predicates_;
  _impl_.predicates_ = nullptr;
  return temp;
}
inline ::milvus::proto::plan::Expr* QueryPlanNode::_internal_mutable_predicates() {
  
  if (_impl_.predicates_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::plan::Expr>(GetArenaForAllocation());
    _impl_.predicates_ = p;
  }
  return _impl_.predicates_;
}
inline ::milvus::proto::plan::Expr* QueryPlanNode::mutable_predicates() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_predicates();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.QueryPlanNode.predicates)
  return _msg;
}
inline void QueryPlanNode::set_allocated_predicates(::milvus::proto::plan::Expr* predicates) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.predicates_;
  }
  if (predicates) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(predicates);
    if (message_arena != submessage_arena) {
      predicates = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, predicates, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.predicates_ = predicates;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.QueryPlanNode.predicates)
}

// bool is_count = 2;
inline void QueryPlanNode::clear_is_count() {
  _impl_.is_count_ = false;
}
inline bool QueryPlanNode::_internal_is_count() const {
  return _impl_.is_count_;
}
inline bool QueryPlanNode::is_count() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.QueryPlanNode.is_count)
  return _internal_is_count();
}
inline void QueryPlanNode::_internal_set_is_count(bool value) {
  
  _impl_.is_count_ = value;
}
inline void QueryPlanNode::set_is_count(bool value) {
  _internal_set_is_count(value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.QueryPlanNode.is_count)
}

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

// PlanNode

// .milvus.proto.plan.VectorANNS vector_anns = 1;
inline bool PlanNode::_internal_has_vector_anns() const {
  return node_case() == kVectorAnns;
}
inline bool PlanNode::has_vector_anns() const {
  return _internal_has_vector_anns();
}
inline void PlanNode::set_has_vector_anns() {
  _impl_._oneof_case_[0] = kVectorAnns;
}
inline void PlanNode::clear_vector_anns() {
  if (_internal_has_vector_anns()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.node_.vector_anns_;
    }
    clear_has_node();
  }
}
inline ::milvus::proto::plan::VectorANNS* PlanNode::release_vector_anns() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.PlanNode.vector_anns)
  if (_internal_has_vector_anns()) {
    clear_has_node();
    ::milvus::proto::plan::VectorANNS* temp = _impl_.node_.vector_anns_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.vector_anns_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::VectorANNS& PlanNode::_internal_vector_anns() const {
  return _internal_has_vector_anns()
      ? *_impl_.node_.vector_anns_
      : reinterpret_cast< ::milvus::proto::plan::VectorANNS&>(::milvus::proto::plan::_VectorANNS_default_instance_);
}
inline const ::milvus::proto::plan::VectorANNS& PlanNode::vector_anns() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.PlanNode.vector_anns)
  return _internal_vector_anns();
}
inline ::milvus::proto::plan::VectorANNS* PlanNode::unsafe_arena_release_vector_anns() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.PlanNode.vector_anns)
  if (_internal_has_vector_anns()) {
    clear_has_node();
    ::milvus::proto::plan::VectorANNS* temp = _impl_.node_.vector_anns_;
    _impl_.node_.vector_anns_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PlanNode::unsafe_arena_set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns) {
  clear_node();
  if (vector_anns) {
    set_has_vector_anns();
    _impl_.node_.vector_anns_ = vector_anns;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.PlanNode.vector_anns)
}
inline ::milvus::proto::plan::VectorANNS* PlanNode::_internal_mutable_vector_anns() {
  if (!_internal_has_vector_anns()) {
    clear_node();
    set_has_vector_anns();
    _impl_.node_.vector_anns_ = CreateMaybeMessage< ::milvus::proto::plan::VectorANNS >(GetArenaForAllocation());
  }
  return _impl_.node_.vector_anns_;
}
inline ::milvus::proto::plan::VectorANNS* PlanNode::mutable_vector_anns() {
  ::milvus::proto::plan::VectorANNS* _msg = _internal_mutable_vector_anns();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.PlanNode.vector_anns)
  return _msg;
}

// .milvus.proto.plan.Expr predicates = 2;
inline bool PlanNode::_internal_has_predicates() const {
  return node_case() == kPredicates;
}
inline bool PlanNode::has_predicates() const {
  return _internal_has_predicates();
}
inline void PlanNode::set_has_predicates() {
  _impl_._oneof_case_[0] = kPredicates;
}
inline void PlanNode::clear_predicates() {
  if (_internal_has_predicates()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.node_.predicates_;
    }
    clear_has_node();
  }
}
inline ::milvus::proto::plan::Expr* PlanNode::release_predicates() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.PlanNode.predicates)
  if (_internal_has_predicates()) {
    clear_has_node();
    ::milvus::proto::plan::Expr* temp = _impl_.node_.predicates_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.predicates_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::Expr& PlanNode::_internal_predicates() const {
  return _internal_has_predicates()
      ? *_impl_.node_.predicates_
      : reinterpret_cast< ::milvus::proto::plan::Expr&>(::milvus::proto::plan::_Expr_default_instance_);
}
inline const ::milvus::proto::plan::Expr& PlanNode::predicates() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.PlanNode.predicates)
  return _internal_predicates();
}
inline ::milvus::proto::plan::Expr* PlanNode::unsafe_arena_release_predicates() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.PlanNode.predicates)
  if (_internal_has_predicates()) {
    clear_has_node();
    ::milvus::proto::plan::Expr* temp = _impl_.node_.predicates_;
    _impl_.node_.predicates_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PlanNode::unsafe_arena_set_allocated_predicates(::milvus::proto::plan::Expr* predicates) {
  clear_node();
  if (predicates) {
    set_has_predicates();
    _impl_.node_.predicates_ = predicates;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.PlanNode.predicates)
}
inline ::milvus::proto::plan::Expr* PlanNode::_internal_mutable_predicates() {
  if (!_internal_has_predicates()) {
    clear_node();
    set_has_predicates();
    _impl_.node_.predicates_ = CreateMaybeMessage< ::milvus::proto::plan::Expr >(GetArenaForAllocation());
  }
  return _impl_.node_.predicates_;
}
inline ::milvus::proto::plan::Expr* PlanNode::mutable_predicates() {
  ::milvus::proto::plan::Expr* _msg = _internal_mutable_predicates();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.PlanNode.predicates)
  return _msg;
}

// .milvus.proto.plan.QueryPlanNode query = 4;
inline bool PlanNode::_internal_has_query() const {
  return node_case() == kQuery;
}
inline bool PlanNode::has_query() const {
  return _internal_has_query();
}
inline void PlanNode::set_has_query() {
  _impl_._oneof_case_[0] = kQuery;
}
inline void PlanNode::clear_query() {
  if (_internal_has_query()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.node_.query_;
    }
    clear_has_node();
  }
}
inline ::milvus::proto::plan::QueryPlanNode* PlanNode::release_query() {
  // @@protoc_insertion_point(field_release:milvus.proto.plan.PlanNode.query)
  if (_internal_has_query()) {
    clear_has_node();
    ::milvus::proto::plan::QueryPlanNode* temp = _impl_.node_.query_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::milvus::proto::plan::QueryPlanNode& PlanNode::_internal_query() const {
  return _internal_has_query()
      ? *_impl_.node_.query_
      : reinterpret_cast< ::milvus::proto::plan::QueryPlanNode&>(::milvus::proto::plan::_QueryPlanNode_default_instance_);
}
inline const ::milvus::proto::plan::QueryPlanNode& PlanNode::query() const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.PlanNode.query)
  return _internal_query();
}
inline ::milvus::proto::plan::QueryPlanNode* PlanNode::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_unsafe_arena_release:milvus.proto.plan.PlanNode.query)
  if (_internal_has_query()) {
    clear_has_node();
    ::milvus::proto::plan::QueryPlanNode* temp = _impl_.node_.query_;
    _impl_.node_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PlanNode::unsafe_arena_set_allocated_query(::milvus::proto::plan::QueryPlanNode* query) {
  clear_node();
  if (query) {
    set_has_query();
    _impl_.node_.query_ = query;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.plan.PlanNode.query)
}
inline ::milvus::proto::plan::QueryPlanNode* PlanNode::_internal_mutable_query() {
  if (!_internal_has_query()) {
    clear_node();
    set_has_query();
    _impl_.node_.query_ = CreateMaybeMessage< ::milvus::proto::plan::QueryPlanNode >(GetArenaForAllocation());
  }
  return _impl_.node_.query_;
}
inline ::milvus::proto::plan::QueryPlanNode* PlanNode::mutable_query() {
  ::milvus::proto::plan::QueryPlanNode* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.PlanNode.query)
  return _msg;
}

// repeated int64 output_field_ids = 3;
inline int PlanNode::_internal_output_field_ids_size() const {
  return _impl_.output_field_ids_.size();
}
inline int PlanNode::output_field_ids_size() const {
  return _internal_output_field_ids_size();
}
inline void PlanNode::clear_output_field_ids() {
  _impl_.output_field_ids_.Clear();
}
inline int64_t PlanNode::_internal_output_field_ids(int index) const {
  return _impl_.output_field_ids_.Get(index);
}
inline int64_t PlanNode::output_field_ids(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.plan.PlanNode.output_field_ids)
  return _internal_output_field_ids(index);
}
inline void PlanNode::set_output_field_ids(int index, int64_t value) {
  _impl_.output_field_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.plan.PlanNode.output_field_ids)
}
inline void PlanNode::_internal_add_output_field_ids(int64_t value) {
  _impl_.output_field_ids_.Add(value);
}
inline void PlanNode::add_output_field_ids(int64_t value) {
  _internal_add_output_field_ids(value);
  // @@protoc_insertion_point(field_add:milvus.proto.plan.PlanNode.output_field_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
PlanNode::_internal_output_field_ids() const {
  return _impl_.output_field_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
PlanNode::output_field_ids() const {
  // @@protoc_insertion_point(field_list:milvus.proto.plan.PlanNode.output_field_ids)
  return _internal_output_field_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
PlanNode::_internal_mutable_output_field_ids() {
  return &_impl_.output_field_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
PlanNode::mutable_output_field_ids() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.plan.PlanNode.output_field_ids)
  return _internal_mutable_output_field_ids();
}

inline bool PlanNode::has_node() const {
  return node_case() != NODE_NOT_SET;
}
inline void PlanNode::clear_has_node() {
  _impl_._oneof_case_[0] = NODE_NOT_SET;
}
inline PlanNode::NodeCase PlanNode::node_case() const {
  return PlanNode::NodeCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace plan
}  // namespace proto
}  // namespace milvus

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::milvus::proto::plan::UnaryExpr_UnaryOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::plan::UnaryExpr_UnaryOp>() {
  return ::milvus::proto::plan::UnaryExpr_UnaryOp_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::plan::BinaryExpr_BinaryOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::plan::BinaryExpr_BinaryOp>() {
  return ::milvus::proto::plan::BinaryExpr_BinaryOp_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::plan::OpType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::plan::OpType>() {
  return ::milvus::proto::plan::OpType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::plan::ArithOpType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::plan::ArithOpType>() {
  return ::milvus::proto::plan::ArithOpType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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