admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity
milvus/internal/core/src/pb/plan.pb.h
Enwei Jiao 564173dcbc
Upgrade protobuf to 3.21.9 (#21679) 
Signed-off-by: Enwei Jiao <enwei.jiao@zilliz.com>
2023-01-13 14:05:41 +08:00

7578 lines
278 KiB
C++
Raw Blame History

// 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 3021009 < 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 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::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 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,
NODE_NOT_SET = 0,
};
static inline const PlanNode* internal_default_instance() {
return reinterpret_cast<const PlanNode*>(
&_PlanNode_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
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,
};
// 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();
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();
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_;
} 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)
}
// -------------------------------------------------------------------
// 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;
}
// 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
Reference in New Issue View Git Blame Copy Permalink