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

#include "plan.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_BinaryExpr_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_BinaryRangeExpr_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ColumnInfo_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CompareExpr_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_GenericValue_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryInfo_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TermExpr_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_UnaryRangeExpr_plan_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorANNS_plan_2eproto;
namespace milvus {
namespace proto {
namespace plan {
class GenericValueDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<GenericValue> _instance;
  bool bool_val_;
  ::PROTOBUF_NAMESPACE_ID::int64 int64_val_;
  double float_val_;
} _GenericValue_default_instance_;
class QueryInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryInfo> _instance;
} _QueryInfo_default_instance_;
class ColumnInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ColumnInfo> _instance;
} _ColumnInfo_default_instance_;
class UnaryRangeExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<UnaryRangeExpr> _instance;
} _UnaryRangeExpr_default_instance_;
class BinaryRangeExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BinaryRangeExpr> _instance;
} _BinaryRangeExpr_default_instance_;
class CompareExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CompareExpr> _instance;
} _CompareExpr_default_instance_;
class TermExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TermExpr> _instance;
} _TermExpr_default_instance_;
class UnaryExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<UnaryExpr> _instance;
} _UnaryExpr_default_instance_;
class BinaryExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BinaryExpr> _instance;
} _BinaryExpr_default_instance_;
class ExprDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Expr> _instance;
  const ::milvus::proto::plan::TermExpr* term_expr_;
  const ::milvus::proto::plan::UnaryExpr* unary_expr_;
  const ::milvus::proto::plan::BinaryExpr* binary_expr_;
  const ::milvus::proto::plan::CompareExpr* compare_expr_;
  const ::milvus::proto::plan::UnaryRangeExpr* unary_range_expr_;
  const ::milvus::proto::plan::BinaryRangeExpr* binary_range_expr_;
} _Expr_default_instance_;
class VectorANNSDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<VectorANNS> _instance;
} _VectorANNS_default_instance_;
class PlanNodeDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlanNode> _instance;
  const ::milvus::proto::plan::VectorANNS* vector_anns_;
} _PlanNode_default_instance_;
}  // namespace plan
}  // namespace proto
}  // namespace milvus
static void InitDefaultsscc_info_BinaryExpr_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_UnaryExpr_default_instance_;
    new (ptr) ::milvus::proto::plan::UnaryExpr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  {
    void* ptr = &::milvus::proto::plan::_BinaryExpr_default_instance_;
    new (ptr) ::milvus::proto::plan::BinaryExpr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  {
    void* ptr = &::milvus::proto::plan::_Expr_default_instance_;
    new (ptr) ::milvus::proto::plan::Expr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::UnaryExpr::InitAsDefaultInstance();
  ::milvus::proto::plan::BinaryExpr::InitAsDefaultInstance();
  ::milvus::proto::plan::Expr::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_BinaryExpr_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, InitDefaultsscc_info_BinaryExpr_plan_2eproto}, {
      &scc_info_TermExpr_plan_2eproto.base,
      &scc_info_CompareExpr_plan_2eproto.base,
      &scc_info_UnaryRangeExpr_plan_2eproto.base,
      &scc_info_BinaryRangeExpr_plan_2eproto.base,}};

static void InitDefaultsscc_info_BinaryRangeExpr_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_BinaryRangeExpr_default_instance_;
    new (ptr) ::milvus::proto::plan::BinaryRangeExpr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::BinaryRangeExpr::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_BinaryRangeExpr_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_BinaryRangeExpr_plan_2eproto}, {
      &scc_info_ColumnInfo_plan_2eproto.base,
      &scc_info_GenericValue_plan_2eproto.base,}};

static void InitDefaultsscc_info_ColumnInfo_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_ColumnInfo_default_instance_;
    new (ptr) ::milvus::proto::plan::ColumnInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::ColumnInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ColumnInfo_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_ColumnInfo_plan_2eproto}, {}};

static void InitDefaultsscc_info_CompareExpr_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_CompareExpr_default_instance_;
    new (ptr) ::milvus::proto::plan::CompareExpr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::CompareExpr::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CompareExpr_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CompareExpr_plan_2eproto}, {
      &scc_info_ColumnInfo_plan_2eproto.base,}};

static void InitDefaultsscc_info_GenericValue_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_GenericValue_default_instance_;
    new (ptr) ::milvus::proto::plan::GenericValue();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::GenericValue::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_GenericValue_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_GenericValue_plan_2eproto}, {}};

static void InitDefaultsscc_info_PlanNode_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_PlanNode_default_instance_;
    new (ptr) ::milvus::proto::plan::PlanNode();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::PlanNode::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PlanNode_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PlanNode_plan_2eproto}, {
      &scc_info_VectorANNS_plan_2eproto.base,}};

static void InitDefaultsscc_info_QueryInfo_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_QueryInfo_default_instance_;
    new (ptr) ::milvus::proto::plan::QueryInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::QueryInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryInfo_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_QueryInfo_plan_2eproto}, {}};

static void InitDefaultsscc_info_TermExpr_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_TermExpr_default_instance_;
    new (ptr) ::milvus::proto::plan::TermExpr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::TermExpr::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TermExpr_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TermExpr_plan_2eproto}, {
      &scc_info_ColumnInfo_plan_2eproto.base,
      &scc_info_GenericValue_plan_2eproto.base,}};

static void InitDefaultsscc_info_UnaryRangeExpr_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_UnaryRangeExpr_default_instance_;
    new (ptr) ::milvus::proto::plan::UnaryRangeExpr();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::UnaryRangeExpr::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_UnaryRangeExpr_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_UnaryRangeExpr_plan_2eproto}, {
      &scc_info_ColumnInfo_plan_2eproto.base,
      &scc_info_GenericValue_plan_2eproto.base,}};

static void InitDefaultsscc_info_VectorANNS_plan_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::milvus::proto::plan::_VectorANNS_default_instance_;
    new (ptr) ::milvus::proto::plan::VectorANNS();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::milvus::proto::plan::VectorANNS::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorANNS_plan_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_VectorANNS_plan_2eproto}, {
      &scc_info_BinaryExpr_plan_2eproto.base,
      &scc_info_QueryInfo_plan_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[12];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_plan_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_plan_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::GenericValue, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::GenericValue, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::milvus::proto::plan::GenericValueDefaultTypeInternal, bool_val_),
  offsetof(::milvus::proto::plan::GenericValueDefaultTypeInternal, int64_val_),
  offsetof(::milvus::proto::plan::GenericValueDefaultTypeInternal, float_val_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::GenericValue, val_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, topk_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, metric_type_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, search_params_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, field_id_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, data_type_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, is_primary_key_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, is_autoid_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, value_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, lower_inclusive_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, upper_inclusive_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, lower_value_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, upper_value_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, left_column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, right_column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, op_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::TermExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::TermExpr, column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::TermExpr, values_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryExpr, op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryExpr, child_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, left_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, right_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, term_expr_),
  offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, unary_expr_),
  offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, binary_expr_),
  offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, compare_expr_),
  offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, unary_range_expr_),
  offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, binary_range_expr_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, expr_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, is_binary_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, field_id_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, predicates_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, query_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, placeholder_tag_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::milvus::proto::plan::PlanNodeDefaultTypeInternal, vector_anns_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, output_field_ids_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, node_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, sizeof(::milvus::proto::plan::GenericValue)},
  { 9, -1, sizeof(::milvus::proto::plan::QueryInfo)},
  { 17, -1, sizeof(::milvus::proto::plan::ColumnInfo)},
  { 26, -1, sizeof(::milvus::proto::plan::UnaryRangeExpr)},
  { 34, -1, sizeof(::milvus::proto::plan::BinaryRangeExpr)},
  { 44, -1, sizeof(::milvus::proto::plan::CompareExpr)},
  { 52, -1, sizeof(::milvus::proto::plan::TermExpr)},
  { 59, -1, sizeof(::milvus::proto::plan::UnaryExpr)},
  { 66, -1, sizeof(::milvus::proto::plan::BinaryExpr)},
  { 74, -1, sizeof(::milvus::proto::plan::Expr)},
  { 86, -1, sizeof(::milvus::proto::plan::VectorANNS)},
  { 96, -1, sizeof(::milvus::proto::plan::PlanNode)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_GenericValue_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_QueryInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_ColumnInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_UnaryRangeExpr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_BinaryRangeExpr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_CompareExpr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_TermExpr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_UnaryExpr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_BinaryExpr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_Expr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_VectorANNS_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::plan::_PlanNode_default_instance_),
};

const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\nplan.proto\022\021milvus.proto.plan\032\014schema."
  "proto\"S\n\014GenericValue\022\022\n\010bool_val\030\001 \001(\010H"
  "\000\022\023\n\tint64_val\030\002 \001(\003H\000\022\023\n\tfloat_val\030\003 \001("
  "\001H\000B\005\n\003val\"E\n\tQueryInfo\022\014\n\004topk\030\001 \001(\003\022\023\n"
  "\013metric_type\030\003 \001(\t\022\025\n\rsearch_params\030\004 \001("
  "\t\"{\n\nColumnInfo\022\020\n\010field_id\030\001 \001(\003\0220\n\tdat"
  "a_type\030\002 \001(\0162\035.milvus.proto.schema.DataT"
  "ype\022\026\n\016is_primary_key\030\003 \001(\010\022\021\n\tis_autoID"
  "\030\004 \001(\010\"\233\001\n\016UnaryRangeExpr\0222\n\013column_info"
  "\030\001 \001(\0132\035.milvus.proto.plan.ColumnInfo\022%\n"
  "\002op\030\002 \001(\0162\031.milvus.proto.plan.OpType\022.\n\005"
  "value\030\003 \001(\0132\037.milvus.proto.plan.GenericV"
  "alue\"\343\001\n\017BinaryRangeExpr\0222\n\013column_info\030"
  "\001 \001(\0132\035.milvus.proto.plan.ColumnInfo\022\027\n\017"
  "lower_inclusive\030\002 \001(\010\022\027\n\017upper_inclusive"
  "\030\003 \001(\010\0224\n\013lower_value\030\004 \001(\0132\037.milvus.pro"
  "to.plan.GenericValue\0224\n\013upper_value\030\005 \001("
  "\0132\037.milvus.proto.plan.GenericValue\"\247\001\n\013C"
  "ompareExpr\0227\n\020left_column_info\030\001 \001(\0132\035.m"
  "ilvus.proto.plan.ColumnInfo\0228\n\021right_col"
  "umn_info\030\002 \001(\0132\035.milvus.proto.plan.Colum"
  "nInfo\022%\n\002op\030\003 \001(\0162\031.milvus.proto.plan.Op"
  "Type\"o\n\010TermExpr\0222\n\013column_info\030\001 \001(\0132\035."
  "milvus.proto.plan.ColumnInfo\022/\n\006values\030\002"
  " \003(\0132\037.milvus.proto.plan.GenericValue\"\206\001"
  "\n\tUnaryExpr\0220\n\002op\030\001 \001(\0162$.milvus.proto.p"
  "lan.UnaryExpr.UnaryOp\022&\n\005child\030\002 \001(\0132\027.m"
  "ilvus.proto.plan.Expr\"\037\n\007UnaryOp\022\013\n\007Inva"
  "lid\020\000\022\007\n\003Not\020\001\"\307\001\n\nBinaryExpr\0222\n\002op\030\001 \001("
  "\0162&.milvus.proto.plan.BinaryExpr.BinaryO"
  "p\022%\n\004left\030\002 \001(\0132\027.milvus.proto.plan.Expr"
  "\022&\n\005right\030\003 \001(\0132\027.milvus.proto.plan.Expr"
  "\"6\n\010BinaryOp\022\013\n\007Invalid\020\000\022\016\n\nLogicalAnd\020"
  "\001\022\r\n\tLogicalOr\020\002\"\342\002\n\004Expr\0220\n\tterm_expr\030\001"
  " \001(\0132\033.milvus.proto.plan.TermExprH\000\0222\n\nu"
  "nary_expr\030\002 \001(\0132\034.milvus.proto.plan.Unar"
  "yExprH\000\0224\n\013binary_expr\030\003 \001(\0132\035.milvus.pr"
  "oto.plan.BinaryExprH\000\0226\n\014compare_expr\030\004 "
  "\001(\0132\036.milvus.proto.plan.CompareExprH\000\022=\n"
  "\020unary_range_expr\030\005 \001(\0132!.milvus.proto.p"
  "lan.UnaryRangeExprH\000\022\?\n\021binary_range_exp"
  "r\030\006 \001(\0132\".milvus.proto.plan.BinaryRangeE"
  "xprH\000B\006\n\004expr\"\251\001\n\nVectorANNS\022\021\n\tis_binar"
  "y\030\001 \001(\010\022\020\n\010field_id\030\002 \001(\003\022+\n\npredicates\030"
  "\003 \001(\0132\027.milvus.proto.plan.Expr\0220\n\nquery_"
  "info\030\004 \001(\0132\034.milvus.proto.plan.QueryInfo"
  "\022\027\n\017placeholder_tag\030\005 \001(\t\"b\n\010PlanNode\0224\n"
  "\013vector_anns\030\001 \001(\0132\035.milvus.proto.plan.V"
  "ectorANNSH\000\022\030\n\020output_field_ids\030\002 \003(\003B\006\n"
  "\004node*n\n\006OpType\022\013\n\007Invalid\020\000\022\017\n\013GreaterT"
  "han\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010LessThan\020\003\022\r\n"
  "\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010NotEqual\020\006B3Z"
  "1github.com/milvus-io/milvus/internal/pr"
  "oto/planpbb\006proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[1] = {
  &::descriptor_table_schema_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_plan_2eproto_sccs[10] = {
  &scc_info_BinaryExpr_plan_2eproto.base,
  &scc_info_BinaryRangeExpr_plan_2eproto.base,
  &scc_info_ColumnInfo_plan_2eproto.base,
  &scc_info_CompareExpr_plan_2eproto.base,
  &scc_info_GenericValue_plan_2eproto.base,
  &scc_info_PlanNode_plan_2eproto.base,
  &scc_info_QueryInfo_plan_2eproto.base,
  &scc_info_TermExpr_plan_2eproto.base,
  &scc_info_UnaryRangeExpr_plan_2eproto.base,
  &scc_info_VectorANNS_plan_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_plan_2eproto_once;
static bool descriptor_table_plan_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto = {
  &descriptor_table_plan_2eproto_initialized, descriptor_table_protodef_plan_2eproto, "plan.proto", 2138,
  &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_sccs, descriptor_table_plan_2eproto_deps, 10, 1,
  schemas, file_default_instances, TableStruct_plan_2eproto::offsets,
  file_level_metadata_plan_2eproto, 12, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_plan_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_plan_2eproto), true);
namespace milvus {
namespace proto {
namespace plan {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* UnaryExpr_UnaryOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[0];
}
bool UnaryExpr_UnaryOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr UnaryExpr_UnaryOp UnaryExpr::Invalid;
constexpr UnaryExpr_UnaryOp UnaryExpr::Not;
constexpr UnaryExpr_UnaryOp UnaryExpr::UnaryOp_MIN;
constexpr UnaryExpr_UnaryOp UnaryExpr::UnaryOp_MAX;
constexpr int UnaryExpr::UnaryOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BinaryExpr_BinaryOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[1];
}
bool BinaryExpr_BinaryOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr BinaryExpr_BinaryOp BinaryExpr::Invalid;
constexpr BinaryExpr_BinaryOp BinaryExpr::LogicalAnd;
constexpr BinaryExpr_BinaryOp BinaryExpr::LogicalOr;
constexpr BinaryExpr_BinaryOp BinaryExpr::BinaryOp_MIN;
constexpr BinaryExpr_BinaryOp BinaryExpr::BinaryOp_MAX;
constexpr int BinaryExpr::BinaryOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[2];
}
bool OpType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}


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

void GenericValue::InitAsDefaultInstance() {
  ::milvus::proto::plan::_GenericValue_default_instance_.bool_val_ = false;
  ::milvus::proto::plan::_GenericValue_default_instance_.int64_val_ = PROTOBUF_LONGLONG(0);
  ::milvus::proto::plan::_GenericValue_default_instance_.float_val_ = 0;
}
class GenericValue::_Internal {
 public:
};

GenericValue::GenericValue()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.GenericValue)
}
GenericValue::GenericValue(const GenericValue& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_val();
  switch (from.val_case()) {
    case kBoolVal: {
      set_bool_val(from.bool_val());
      break;
    }
    case kInt64Val: {
      set_int64_val(from.int64_val());
      break;
    }
    case kFloatVal: {
      set_float_val(from.float_val());
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.GenericValue)
}

void GenericValue::SharedCtor() {
  clear_has_val();
}

GenericValue::~GenericValue() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.GenericValue)
  SharedDtor();
}

void GenericValue::SharedDtor() {
  if (has_val()) {
    clear_val();
  }
}

void GenericValue::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const GenericValue& GenericValue::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GenericValue_plan_2eproto.base);
  return *internal_default_instance();
}


void GenericValue::clear_val() {
// @@protoc_insertion_point(one_of_clear_start:milvus.proto.plan.GenericValue)
  switch (val_case()) {
    case kBoolVal: {
      // No need to clear
      break;
    }
    case kInt64Val: {
      // No need to clear
      break;
    }
    case kFloatVal: {
      // No need to clear
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = VAL_NOT_SET;
}


void GenericValue::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.GenericValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_val();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* GenericValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool bool_val = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          set_bool_val(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int64 int64_val = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          set_int64_val(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // double float_val = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          set_float_val(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool GenericValue::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.GenericValue)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // bool bool_val = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          clear_val();
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &val_.bool_val_)));
          set_has_bool_val();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // int64 int64_val = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          clear_val();
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, &val_.int64_val_)));
          set_has_int64_val();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // double float_val = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (25 & 0xFF)) {
          clear_val();
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &val_.float_val_)));
          set_has_float_val();
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.GenericValue)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.GenericValue)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void GenericValue::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.GenericValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool bool_val = 1;
  if (has_bool_val()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->bool_val(), output);
  }

  // int64 int64_val = 2;
  if (has_int64_val()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->int64_val(), output);
  }

  // double float_val = 3;
  if (has_float_val()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(3, this->float_val(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.GenericValue)
}

::PROTOBUF_NAMESPACE_ID::uint8* GenericValue::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.GenericValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool bool_val = 1;
  if (has_bool_val()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->bool_val(), target);
  }

  // int64 int64_val = 2;
  if (has_int64_val()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->int64_val(), target);
  }

  // double float_val = 3;
  if (has_float_val()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->float_val(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.GenericValue)
  return target;
}

size_t GenericValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.GenericValue)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (val_case()) {
    // bool bool_val = 1;
    case kBoolVal: {
      total_size += 1 + 1;
      break;
    }
    // int64 int64_val = 2;
    case kInt64Val: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->int64_val());
      break;
    }
    // double float_val = 3;
    case kFloatVal: {
      total_size += 1 + 8;
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GenericValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.GenericValue)
  GOOGLE_DCHECK_NE(&from, this);
  const GenericValue* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GenericValue>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.GenericValue)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.GenericValue)
    MergeFrom(*source);
  }
}

void GenericValue::MergeFrom(const GenericValue& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.GenericValue)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.val_case()) {
    case kBoolVal: {
      set_bool_val(from.bool_val());
      break;
    }
    case kInt64Val: {
      set_int64_val(from.int64_val());
      break;
    }
    case kFloatVal: {
      set_float_val(from.float_val());
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
}

void GenericValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.GenericValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void GenericValue::CopyFrom(const GenericValue& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.GenericValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GenericValue::IsInitialized() const {
  return true;
}

void GenericValue::InternalSwap(GenericValue* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(val_, other->val_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata GenericValue::GetMetadata() const {
  return GetMetadataStatic();
}


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

void QueryInfo::InitAsDefaultInstance() {
}
class QueryInfo::_Internal {
 public:
};

QueryInfo::QueryInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.QueryInfo)
}
QueryInfo::QueryInfo(const QueryInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  metric_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from.metric_type().empty()) {
    metric_type_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.metric_type_);
  }
  search_params_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from.search_params().empty()) {
    search_params_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.search_params_);
  }
  topk_ = from.topk_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.QueryInfo)
}

void QueryInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryInfo_plan_2eproto.base);
  metric_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  search_params_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  topk_ = PROTOBUF_LONGLONG(0);
}

QueryInfo::~QueryInfo() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.QueryInfo)
  SharedDtor();
}

void QueryInfo::SharedDtor() {
  metric_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  search_params_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void QueryInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const QueryInfo& QueryInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryInfo_plan_2eproto.base);
  return *internal_default_instance();
}


void QueryInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.QueryInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  metric_type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  search_params_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  topk_ = PROTOBUF_LONGLONG(0);
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* QueryInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int64 topk = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          topk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string metric_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_metric_type(), ptr, ctx, "milvus.proto.plan.QueryInfo.metric_type");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string search_params = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_search_params(), ptr, ctx, "milvus.proto.plan.QueryInfo.search_params");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool QueryInfo::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.QueryInfo)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // int64 topk = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, &topk_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string metric_type = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_metric_type()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->metric_type().data(), static_cast<int>(this->metric_type().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "milvus.proto.plan.QueryInfo.metric_type"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string search_params = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_search_params()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->search_params().data(), static_cast<int>(this->search_params().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "milvus.proto.plan.QueryInfo.search_params"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.QueryInfo)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.QueryInfo)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void QueryInfo::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.QueryInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 topk = 1;
  if (this->topk() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->topk(), output);
  }

  // string metric_type = 3;
  if (this->metric_type().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->metric_type().data(), static_cast<int>(this->metric_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.QueryInfo.metric_type");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->metric_type(), output);
  }

  // string search_params = 4;
  if (this->search_params().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->search_params().data(), static_cast<int>(this->search_params().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.QueryInfo.search_params");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->search_params(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.QueryInfo)
}

::PROTOBUF_NAMESPACE_ID::uint8* QueryInfo::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.QueryInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 topk = 1;
  if (this->topk() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->topk(), target);
  }

  // string metric_type = 3;
  if (this->metric_type().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->metric_type().data(), static_cast<int>(this->metric_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.QueryInfo.metric_type");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        3, this->metric_type(), target);
  }

  // string search_params = 4;
  if (this->search_params().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->search_params().data(), static_cast<int>(this->search_params().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.QueryInfo.search_params");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        4, this->search_params(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.QueryInfo)
  return target;
}

size_t QueryInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.QueryInfo)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string metric_type = 3;
  if (this->metric_type().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->metric_type());
  }

  // string search_params = 4;
  if (this->search_params().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->search_params());
  }

  // int64 topk = 1;
  if (this->topk() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->topk());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void QueryInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.QueryInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const QueryInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.QueryInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.QueryInfo)
    MergeFrom(*source);
  }
}

void QueryInfo::MergeFrom(const QueryInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.QueryInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.metric_type().size() > 0) {

    metric_type_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.metric_type_);
  }
  if (from.search_params().size() > 0) {

    search_params_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.search_params_);
  }
  if (from.topk() != 0) {
    set_topk(from.topk());
  }
}

void QueryInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.QueryInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryInfo::CopyFrom(const QueryInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.QueryInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryInfo::IsInitialized() const {
  return true;
}

void QueryInfo::InternalSwap(QueryInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  metric_type_.Swap(&other->metric_type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  search_params_.Swap(&other->search_params_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(topk_, other->topk_);
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryInfo::GetMetadata() const {
  return GetMetadataStatic();
}


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

void ColumnInfo::InitAsDefaultInstance() {
}
class ColumnInfo::_Internal {
 public:
};

ColumnInfo::ColumnInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.ColumnInfo)
}
ColumnInfo::ColumnInfo(const ColumnInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&field_id_, &from.field_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_autoid_) -
    reinterpret_cast<char*>(&field_id_)) + sizeof(is_autoid_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.ColumnInfo)
}

void ColumnInfo::SharedCtor() {
  ::memset(&field_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_autoid_) -
      reinterpret_cast<char*>(&field_id_)) + sizeof(is_autoid_));
}

ColumnInfo::~ColumnInfo() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.ColumnInfo)
  SharedDtor();
}

void ColumnInfo::SharedDtor() {
}

void ColumnInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ColumnInfo& ColumnInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ColumnInfo_plan_2eproto.base);
  return *internal_default_instance();
}


void ColumnInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.ColumnInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&field_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_autoid_) -
      reinterpret_cast<char*>(&field_id_)) + sizeof(is_autoid_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ColumnInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int64 field_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          field_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.schema.DataType data_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_data_type(static_cast<::milvus::proto::schema::DataType>(val));
        } else goto handle_unusual;
        continue;
      // bool is_primary_key = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          is_primary_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool is_autoID = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          is_autoid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ColumnInfo::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.ColumnInfo)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // int64 field_id = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, &field_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.schema.DataType data_type = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_data_type(static_cast< ::milvus::proto::schema::DataType >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool is_primary_key = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_primary_key_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool is_autoID = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_autoid_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.ColumnInfo)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.ColumnInfo)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void ColumnInfo::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.ColumnInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 field_id = 1;
  if (this->field_id() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->field_id(), output);
  }

  // .milvus.proto.schema.DataType data_type = 2;
  if (this->data_type() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->data_type(), output);
  }

  // bool is_primary_key = 3;
  if (this->is_primary_key() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->is_primary_key(), output);
  }

  // bool is_autoID = 4;
  if (this->is_autoid() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(4, this->is_autoid(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.ColumnInfo)
}

::PROTOBUF_NAMESPACE_ID::uint8* ColumnInfo::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.ColumnInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 field_id = 1;
  if (this->field_id() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->field_id(), target);
  }

  // .milvus.proto.schema.DataType data_type = 2;
  if (this->data_type() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->data_type(), target);
  }

  // bool is_primary_key = 3;
  if (this->is_primary_key() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->is_primary_key(), target);
  }

  // bool is_autoID = 4;
  if (this->is_autoid() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->is_autoid(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.ColumnInfo)
  return target;
}

size_t ColumnInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.ColumnInfo)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int64 field_id = 1;
  if (this->field_id() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->field_id());
  }

  // .milvus.proto.schema.DataType data_type = 2;
  if (this->data_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->data_type());
  }

  // bool is_primary_key = 3;
  if (this->is_primary_key() != 0) {
    total_size += 1 + 1;
  }

  // bool is_autoID = 4;
  if (this->is_autoid() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ColumnInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.ColumnInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const ColumnInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ColumnInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.ColumnInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.ColumnInfo)
    MergeFrom(*source);
  }
}

void ColumnInfo::MergeFrom(const ColumnInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.ColumnInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.field_id() != 0) {
    set_field_id(from.field_id());
  }
  if (from.data_type() != 0) {
    set_data_type(from.data_type());
  }
  if (from.is_primary_key() != 0) {
    set_is_primary_key(from.is_primary_key());
  }
  if (from.is_autoid() != 0) {
    set_is_autoid(from.is_autoid());
  }
}

void ColumnInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.ColumnInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ColumnInfo::CopyFrom(const ColumnInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.ColumnInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ColumnInfo::IsInitialized() const {
  return true;
}

void ColumnInfo::InternalSwap(ColumnInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(field_id_, other->field_id_);
  swap(data_type_, other->data_type_);
  swap(is_primary_key_, other->is_primary_key_);
  swap(is_autoid_, other->is_autoid_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ColumnInfo::GetMetadata() const {
  return GetMetadataStatic();
}


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

void UnaryRangeExpr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_UnaryRangeExpr_default_instance_._instance.get_mutable()->column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>(
      ::milvus::proto::plan::ColumnInfo::internal_default_instance());
  ::milvus::proto::plan::_UnaryRangeExpr_default_instance_._instance.get_mutable()->value_ = const_cast< ::milvus::proto::plan::GenericValue*>(
      ::milvus::proto::plan::GenericValue::internal_default_instance());
}
class UnaryRangeExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& column_info(const UnaryRangeExpr* msg);
  static const ::milvus::proto::plan::GenericValue& value(const UnaryRangeExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
UnaryRangeExpr::_Internal::column_info(const UnaryRangeExpr* msg) {
  return *msg->column_info_;
}
const ::milvus::proto::plan::GenericValue&
UnaryRangeExpr::_Internal::value(const UnaryRangeExpr* msg) {
  return *msg->value_;
}
UnaryRangeExpr::UnaryRangeExpr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.UnaryRangeExpr)
}
UnaryRangeExpr::UnaryRangeExpr(const UnaryRangeExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_column_info()) {
    column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.column_info_);
  } else {
    column_info_ = nullptr;
  }
  if (from.has_value()) {
    value_ = new ::milvus::proto::plan::GenericValue(*from.value_);
  } else {
    value_ = nullptr;
  }
  op_ = from.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.UnaryRangeExpr)
}

void UnaryRangeExpr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UnaryRangeExpr_plan_2eproto.base);
  ::memset(&column_info_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&op_) -
      reinterpret_cast<char*>(&column_info_)) + sizeof(op_));
}

UnaryRangeExpr::~UnaryRangeExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.UnaryRangeExpr)
  SharedDtor();
}

void UnaryRangeExpr::SharedDtor() {
  if (this != internal_default_instance()) delete column_info_;
  if (this != internal_default_instance()) delete value_;
}

void UnaryRangeExpr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const UnaryRangeExpr& UnaryRangeExpr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UnaryRangeExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void UnaryRangeExpr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.UnaryRangeExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) {
    delete column_info_;
  }
  column_info_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && value_ != nullptr) {
    delete value_;
  }
  value_ = nullptr;
  op_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* UnaryRangeExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_column_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.OpType op = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_op(static_cast<::milvus::proto::plan::OpType>(val));
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue value = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(mutable_value(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool UnaryRangeExpr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.UnaryRangeExpr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_column_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.OpType op = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_op(static_cast< ::milvus::proto::plan::OpType >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.GenericValue value = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.UnaryRangeExpr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.UnaryRangeExpr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void UnaryRangeExpr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.UnaryRangeExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, _Internal::column_info(this), output);
  }

  // .milvus.proto.plan.OpType op = 2;
  if (this->op() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->op(), output);
  }

  // .milvus.proto.plan.GenericValue value = 3;
  if (this->has_value()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, _Internal::value(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.UnaryRangeExpr)
}

::PROTOBUF_NAMESPACE_ID::uint8* UnaryRangeExpr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.UnaryRangeExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, _Internal::column_info(this), target);
  }

  // .milvus.proto.plan.OpType op = 2;
  if (this->op() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->op(), target);
  }

  // .milvus.proto.plan.GenericValue value = 3;
  if (this->has_value()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, _Internal::value(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.UnaryRangeExpr)
  return target;
}

size_t UnaryRangeExpr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.UnaryRangeExpr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *column_info_);
  }

  // .milvus.proto.plan.GenericValue value = 3;
  if (this->has_value()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *value_);
  }

  // .milvus.proto.plan.OpType op = 2;
  if (this->op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->op());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void UnaryRangeExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.UnaryRangeExpr)
  GOOGLE_DCHECK_NE(&from, this);
  const UnaryRangeExpr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<UnaryRangeExpr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.UnaryRangeExpr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.UnaryRangeExpr)
    MergeFrom(*source);
  }
}

void UnaryRangeExpr::MergeFrom(const UnaryRangeExpr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.UnaryRangeExpr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_column_info()) {
    mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.column_info());
  }
  if (from.has_value()) {
    mutable_value()->::milvus::proto::plan::GenericValue::MergeFrom(from.value());
  }
  if (from.op() != 0) {
    set_op(from.op());
  }
}

void UnaryRangeExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.UnaryRangeExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UnaryRangeExpr::CopyFrom(const UnaryRangeExpr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.UnaryRangeExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UnaryRangeExpr::IsInitialized() const {
  return true;
}

void UnaryRangeExpr::InternalSwap(UnaryRangeExpr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(column_info_, other->column_info_);
  swap(value_, other->value_);
  swap(op_, other->op_);
}

::PROTOBUF_NAMESPACE_ID::Metadata UnaryRangeExpr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void BinaryRangeExpr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_BinaryRangeExpr_default_instance_._instance.get_mutable()->column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>(
      ::milvus::proto::plan::ColumnInfo::internal_default_instance());
  ::milvus::proto::plan::_BinaryRangeExpr_default_instance_._instance.get_mutable()->lower_value_ = const_cast< ::milvus::proto::plan::GenericValue*>(
      ::milvus::proto::plan::GenericValue::internal_default_instance());
  ::milvus::proto::plan::_BinaryRangeExpr_default_instance_._instance.get_mutable()->upper_value_ = const_cast< ::milvus::proto::plan::GenericValue*>(
      ::milvus::proto::plan::GenericValue::internal_default_instance());
}
class BinaryRangeExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& column_info(const BinaryRangeExpr* msg);
  static const ::milvus::proto::plan::GenericValue& lower_value(const BinaryRangeExpr* msg);
  static const ::milvus::proto::plan::GenericValue& upper_value(const BinaryRangeExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
BinaryRangeExpr::_Internal::column_info(const BinaryRangeExpr* msg) {
  return *msg->column_info_;
}
const ::milvus::proto::plan::GenericValue&
BinaryRangeExpr::_Internal::lower_value(const BinaryRangeExpr* msg) {
  return *msg->lower_value_;
}
const ::milvus::proto::plan::GenericValue&
BinaryRangeExpr::_Internal::upper_value(const BinaryRangeExpr* msg) {
  return *msg->upper_value_;
}
BinaryRangeExpr::BinaryRangeExpr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.BinaryRangeExpr)
}
BinaryRangeExpr::BinaryRangeExpr(const BinaryRangeExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_column_info()) {
    column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.column_info_);
  } else {
    column_info_ = nullptr;
  }
  if (from.has_lower_value()) {
    lower_value_ = new ::milvus::proto::plan::GenericValue(*from.lower_value_);
  } else {
    lower_value_ = nullptr;
  }
  if (from.has_upper_value()) {
    upper_value_ = new ::milvus::proto::plan::GenericValue(*from.upper_value_);
  } else {
    upper_value_ = nullptr;
  }
  ::memcpy(&lower_inclusive_, &from.lower_inclusive_,
    static_cast<size_t>(reinterpret_cast<char*>(&upper_inclusive_) -
    reinterpret_cast<char*>(&lower_inclusive_)) + sizeof(upper_inclusive_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryRangeExpr)
}

void BinaryRangeExpr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinaryRangeExpr_plan_2eproto.base);
  ::memset(&column_info_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&upper_inclusive_) -
      reinterpret_cast<char*>(&column_info_)) + sizeof(upper_inclusive_));
}

BinaryRangeExpr::~BinaryRangeExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryRangeExpr)
  SharedDtor();
}

void BinaryRangeExpr::SharedDtor() {
  if (this != internal_default_instance()) delete column_info_;
  if (this != internal_default_instance()) delete lower_value_;
  if (this != internal_default_instance()) delete upper_value_;
}

void BinaryRangeExpr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const BinaryRangeExpr& BinaryRangeExpr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinaryRangeExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void BinaryRangeExpr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.BinaryRangeExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) {
    delete column_info_;
  }
  column_info_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && lower_value_ != nullptr) {
    delete lower_value_;
  }
  lower_value_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && upper_value_ != nullptr) {
    delete upper_value_;
  }
  upper_value_ = nullptr;
  ::memset(&lower_inclusive_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&upper_inclusive_) -
      reinterpret_cast<char*>(&lower_inclusive_)) + sizeof(upper_inclusive_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BinaryRangeExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_column_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool lower_inclusive = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          lower_inclusive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool upper_inclusive = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          upper_inclusive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue lower_value = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(mutable_lower_value(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue upper_value = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_upper_value(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BinaryRangeExpr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.BinaryRangeExpr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_column_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool lower_inclusive = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &lower_inclusive_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool upper_inclusive = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &upper_inclusive_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.GenericValue lower_value = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_lower_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.GenericValue upper_value = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_upper_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.BinaryRangeExpr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.BinaryRangeExpr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void BinaryRangeExpr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.BinaryRangeExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, _Internal::column_info(this), output);
  }

  // bool lower_inclusive = 2;
  if (this->lower_inclusive() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->lower_inclusive(), output);
  }

  // bool upper_inclusive = 3;
  if (this->upper_inclusive() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->upper_inclusive(), output);
  }

  // .milvus.proto.plan.GenericValue lower_value = 4;
  if (this->has_lower_value()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, _Internal::lower_value(this), output);
  }

  // .milvus.proto.plan.GenericValue upper_value = 5;
  if (this->has_upper_value()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, _Internal::upper_value(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.BinaryRangeExpr)
}

::PROTOBUF_NAMESPACE_ID::uint8* BinaryRangeExpr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryRangeExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, _Internal::column_info(this), target);
  }

  // bool lower_inclusive = 2;
  if (this->lower_inclusive() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->lower_inclusive(), target);
  }

  // bool upper_inclusive = 3;
  if (this->upper_inclusive() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->upper_inclusive(), target);
  }

  // .milvus.proto.plan.GenericValue lower_value = 4;
  if (this->has_lower_value()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, _Internal::lower_value(this), target);
  }

  // .milvus.proto.plan.GenericValue upper_value = 5;
  if (this->has_upper_value()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, _Internal::upper_value(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryRangeExpr)
  return target;
}

size_t BinaryRangeExpr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.BinaryRangeExpr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *column_info_);
  }

  // .milvus.proto.plan.GenericValue lower_value = 4;
  if (this->has_lower_value()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *lower_value_);
  }

  // .milvus.proto.plan.GenericValue upper_value = 5;
  if (this->has_upper_value()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *upper_value_);
  }

  // bool lower_inclusive = 2;
  if (this->lower_inclusive() != 0) {
    total_size += 1 + 1;
  }

  // bool upper_inclusive = 3;
  if (this->upper_inclusive() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BinaryRangeExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.BinaryRangeExpr)
  GOOGLE_DCHECK_NE(&from, this);
  const BinaryRangeExpr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BinaryRangeExpr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.BinaryRangeExpr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.BinaryRangeExpr)
    MergeFrom(*source);
  }
}

void BinaryRangeExpr::MergeFrom(const BinaryRangeExpr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryRangeExpr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_column_info()) {
    mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.column_info());
  }
  if (from.has_lower_value()) {
    mutable_lower_value()->::milvus::proto::plan::GenericValue::MergeFrom(from.lower_value());
  }
  if (from.has_upper_value()) {
    mutable_upper_value()->::milvus::proto::plan::GenericValue::MergeFrom(from.upper_value());
  }
  if (from.lower_inclusive() != 0) {
    set_lower_inclusive(from.lower_inclusive());
  }
  if (from.upper_inclusive() != 0) {
    set_upper_inclusive(from.upper_inclusive());
  }
}

void BinaryRangeExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.BinaryRangeExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BinaryRangeExpr::CopyFrom(const BinaryRangeExpr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.BinaryRangeExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BinaryRangeExpr::IsInitialized() const {
  return true;
}

void BinaryRangeExpr::InternalSwap(BinaryRangeExpr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(column_info_, other->column_info_);
  swap(lower_value_, other->lower_value_);
  swap(upper_value_, other->upper_value_);
  swap(lower_inclusive_, other->lower_inclusive_);
  swap(upper_inclusive_, other->upper_inclusive_);
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryRangeExpr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void CompareExpr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_CompareExpr_default_instance_._instance.get_mutable()->left_column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>(
      ::milvus::proto::plan::ColumnInfo::internal_default_instance());
  ::milvus::proto::plan::_CompareExpr_default_instance_._instance.get_mutable()->right_column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>(
      ::milvus::proto::plan::ColumnInfo::internal_default_instance());
}
class CompareExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& left_column_info(const CompareExpr* msg);
  static const ::milvus::proto::plan::ColumnInfo& right_column_info(const CompareExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
CompareExpr::_Internal::left_column_info(const CompareExpr* msg) {
  return *msg->left_column_info_;
}
const ::milvus::proto::plan::ColumnInfo&
CompareExpr::_Internal::right_column_info(const CompareExpr* msg) {
  return *msg->right_column_info_;
}
CompareExpr::CompareExpr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.CompareExpr)
}
CompareExpr::CompareExpr(const CompareExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_left_column_info()) {
    left_column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.left_column_info_);
  } else {
    left_column_info_ = nullptr;
  }
  if (from.has_right_column_info()) {
    right_column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.right_column_info_);
  } else {
    right_column_info_ = nullptr;
  }
  op_ = from.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.CompareExpr)
}

void CompareExpr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompareExpr_plan_2eproto.base);
  ::memset(&left_column_info_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&op_) -
      reinterpret_cast<char*>(&left_column_info_)) + sizeof(op_));
}

CompareExpr::~CompareExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.CompareExpr)
  SharedDtor();
}

void CompareExpr::SharedDtor() {
  if (this != internal_default_instance()) delete left_column_info_;
  if (this != internal_default_instance()) delete right_column_info_;
}

void CompareExpr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const CompareExpr& CompareExpr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompareExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void CompareExpr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.CompareExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && left_column_info_ != nullptr) {
    delete left_column_info_;
  }
  left_column_info_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && right_column_info_ != nullptr) {
    delete right_column_info_;
  }
  right_column_info_ = nullptr;
  op_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CompareExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo left_column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_left_column_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.ColumnInfo right_column_info = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_right_column_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.OpType op = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_op(static_cast<::milvus::proto::plan::OpType>(val));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CompareExpr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.CompareExpr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.ColumnInfo left_column_info = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_left_column_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.ColumnInfo right_column_info = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_right_column_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.OpType op = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_op(static_cast< ::milvus::proto::plan::OpType >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.CompareExpr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.CompareExpr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void CompareExpr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.CompareExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo left_column_info = 1;
  if (this->has_left_column_info()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, _Internal::left_column_info(this), output);
  }

  // .milvus.proto.plan.ColumnInfo right_column_info = 2;
  if (this->has_right_column_info()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, _Internal::right_column_info(this), output);
  }

  // .milvus.proto.plan.OpType op = 3;
  if (this->op() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      3, this->op(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.CompareExpr)
}

::PROTOBUF_NAMESPACE_ID::uint8* CompareExpr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.CompareExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo left_column_info = 1;
  if (this->has_left_column_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, _Internal::left_column_info(this), target);
  }

  // .milvus.proto.plan.ColumnInfo right_column_info = 2;
  if (this->has_right_column_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, _Internal::right_column_info(this), target);
  }

  // .milvus.proto.plan.OpType op = 3;
  if (this->op() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->op(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.CompareExpr)
  return target;
}

size_t CompareExpr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.CompareExpr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo left_column_info = 1;
  if (this->has_left_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *left_column_info_);
  }

  // .milvus.proto.plan.ColumnInfo right_column_info = 2;
  if (this->has_right_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *right_column_info_);
  }

  // .milvus.proto.plan.OpType op = 3;
  if (this->op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->op());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CompareExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.CompareExpr)
  GOOGLE_DCHECK_NE(&from, this);
  const CompareExpr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CompareExpr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.CompareExpr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.CompareExpr)
    MergeFrom(*source);
  }
}

void CompareExpr::MergeFrom(const CompareExpr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.CompareExpr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_left_column_info()) {
    mutable_left_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.left_column_info());
  }
  if (from.has_right_column_info()) {
    mutable_right_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.right_column_info());
  }
  if (from.op() != 0) {
    set_op(from.op());
  }
}

void CompareExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.CompareExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CompareExpr::CopyFrom(const CompareExpr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.CompareExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CompareExpr::IsInitialized() const {
  return true;
}

void CompareExpr::InternalSwap(CompareExpr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(left_column_info_, other->left_column_info_);
  swap(right_column_info_, other->right_column_info_);
  swap(op_, other->op_);
}

::PROTOBUF_NAMESPACE_ID::Metadata CompareExpr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void TermExpr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_TermExpr_default_instance_._instance.get_mutable()->column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>(
      ::milvus::proto::plan::ColumnInfo::internal_default_instance());
}
class TermExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& column_info(const TermExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
TermExpr::_Internal::column_info(const TermExpr* msg) {
  return *msg->column_info_;
}
TermExpr::TermExpr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.TermExpr)
}
TermExpr::TermExpr(const TermExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      values_(from.values_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_column_info()) {
    column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.column_info_);
  } else {
    column_info_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.TermExpr)
}

void TermExpr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TermExpr_plan_2eproto.base);
  column_info_ = nullptr;
}

TermExpr::~TermExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.TermExpr)
  SharedDtor();
}

void TermExpr::SharedDtor() {
  if (this != internal_default_instance()) delete column_info_;
}

void TermExpr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const TermExpr& TermExpr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TermExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void TermExpr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.TermExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  values_.Clear();
  if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) {
    delete column_info_;
  }
  column_info_ = nullptr;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TermExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_column_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .milvus.proto.plan.GenericValue values = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_values(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TermExpr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.TermExpr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_column_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .milvus.proto.plan.GenericValue values = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_values()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.TermExpr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.TermExpr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void TermExpr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.TermExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, _Internal::column_info(this), output);
  }

  // repeated .milvus.proto.plan.GenericValue values = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->values_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2,
      this->values(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.TermExpr)
}

::PROTOBUF_NAMESPACE_ID::uint8* TermExpr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.TermExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, _Internal::column_info(this), target);
  }

  // repeated .milvus.proto.plan.GenericValue values = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->values_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->values(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.TermExpr)
  return target;
}

size_t TermExpr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.TermExpr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .milvus.proto.plan.GenericValue values = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->values_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->values(static_cast<int>(i)));
    }
  }

  // .milvus.proto.plan.ColumnInfo column_info = 1;
  if (this->has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *column_info_);
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TermExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.TermExpr)
  GOOGLE_DCHECK_NE(&from, this);
  const TermExpr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TermExpr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.TermExpr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.TermExpr)
    MergeFrom(*source);
  }
}

void TermExpr::MergeFrom(const TermExpr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.TermExpr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  values_.MergeFrom(from.values_);
  if (from.has_column_info()) {
    mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.column_info());
  }
}

void TermExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.TermExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TermExpr::CopyFrom(const TermExpr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.TermExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TermExpr::IsInitialized() const {
  return true;
}

void TermExpr::InternalSwap(TermExpr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&values_)->InternalSwap(CastToBase(&other->values_));
  swap(column_info_, other->column_info_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TermExpr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void UnaryExpr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_UnaryExpr_default_instance_._instance.get_mutable()->child_ = const_cast< ::milvus::proto::plan::Expr*>(
      ::milvus::proto::plan::Expr::internal_default_instance());
}
class UnaryExpr::_Internal {
 public:
  static const ::milvus::proto::plan::Expr& child(const UnaryExpr* msg);
};

const ::milvus::proto::plan::Expr&
UnaryExpr::_Internal::child(const UnaryExpr* msg) {
  return *msg->child_;
}
UnaryExpr::UnaryExpr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.UnaryExpr)
}
UnaryExpr::UnaryExpr(const UnaryExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_child()) {
    child_ = new ::milvus::proto::plan::Expr(*from.child_);
  } else {
    child_ = nullptr;
  }
  op_ = from.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.UnaryExpr)
}

void UnaryExpr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinaryExpr_plan_2eproto.base);
  ::memset(&child_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&op_) -
      reinterpret_cast<char*>(&child_)) + sizeof(op_));
}

UnaryExpr::~UnaryExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.UnaryExpr)
  SharedDtor();
}

void UnaryExpr::SharedDtor() {
  if (this != internal_default_instance()) delete child_;
}

void UnaryExpr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const UnaryExpr& UnaryExpr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinaryExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void UnaryExpr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.UnaryExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && child_ != nullptr) {
    delete child_;
  }
  child_ = nullptr;
  op_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* UnaryExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_op(static_cast<::milvus::proto::plan::UnaryExpr_UnaryOp>(val));
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr child = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_child(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool UnaryExpr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.UnaryExpr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_op(static_cast< ::milvus::proto::plan::UnaryExpr_UnaryOp >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.Expr child = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_child()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.UnaryExpr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.UnaryExpr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void UnaryExpr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.UnaryExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
  if (this->op() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->op(), output);
  }

  // .milvus.proto.plan.Expr child = 2;
  if (this->has_child()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, _Internal::child(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.UnaryExpr)
}

::PROTOBUF_NAMESPACE_ID::uint8* UnaryExpr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.UnaryExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
  if (this->op() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->op(), target);
  }

  // .milvus.proto.plan.Expr child = 2;
  if (this->has_child()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, _Internal::child(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.UnaryExpr)
  return target;
}

size_t UnaryExpr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.UnaryExpr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.Expr child = 2;
  if (this->has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
  if (this->op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->op());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void UnaryExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.UnaryExpr)
  GOOGLE_DCHECK_NE(&from, this);
  const UnaryExpr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<UnaryExpr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.UnaryExpr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.UnaryExpr)
    MergeFrom(*source);
  }
}

void UnaryExpr::MergeFrom(const UnaryExpr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.UnaryExpr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_child()) {
    mutable_child()->::milvus::proto::plan::Expr::MergeFrom(from.child());
  }
  if (from.op() != 0) {
    set_op(from.op());
  }
}

void UnaryExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.UnaryExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UnaryExpr::CopyFrom(const UnaryExpr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.UnaryExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UnaryExpr::IsInitialized() const {
  return true;
}

void UnaryExpr::InternalSwap(UnaryExpr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(child_, other->child_);
  swap(op_, other->op_);
}

::PROTOBUF_NAMESPACE_ID::Metadata UnaryExpr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void BinaryExpr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_BinaryExpr_default_instance_._instance.get_mutable()->left_ = const_cast< ::milvus::proto::plan::Expr*>(
      ::milvus::proto::plan::Expr::internal_default_instance());
  ::milvus::proto::plan::_BinaryExpr_default_instance_._instance.get_mutable()->right_ = const_cast< ::milvus::proto::plan::Expr*>(
      ::milvus::proto::plan::Expr::internal_default_instance());
}
class BinaryExpr::_Internal {
 public:
  static const ::milvus::proto::plan::Expr& left(const BinaryExpr* msg);
  static const ::milvus::proto::plan::Expr& right(const BinaryExpr* msg);
};

const ::milvus::proto::plan::Expr&
BinaryExpr::_Internal::left(const BinaryExpr* msg) {
  return *msg->left_;
}
const ::milvus::proto::plan::Expr&
BinaryExpr::_Internal::right(const BinaryExpr* msg) {
  return *msg->right_;
}
BinaryExpr::BinaryExpr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.BinaryExpr)
}
BinaryExpr::BinaryExpr(const BinaryExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_left()) {
    left_ = new ::milvus::proto::plan::Expr(*from.left_);
  } else {
    left_ = nullptr;
  }
  if (from.has_right()) {
    right_ = new ::milvus::proto::plan::Expr(*from.right_);
  } else {
    right_ = nullptr;
  }
  op_ = from.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryExpr)
}

void BinaryExpr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinaryExpr_plan_2eproto.base);
  ::memset(&left_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&op_) -
      reinterpret_cast<char*>(&left_)) + sizeof(op_));
}

BinaryExpr::~BinaryExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryExpr)
  SharedDtor();
}

void BinaryExpr::SharedDtor() {
  if (this != internal_default_instance()) delete left_;
  if (this != internal_default_instance()) delete right_;
}

void BinaryExpr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const BinaryExpr& BinaryExpr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinaryExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void BinaryExpr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.BinaryExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && left_ != nullptr) {
    delete left_;
  }
  left_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && right_ != nullptr) {
    delete right_;
  }
  right_ = nullptr;
  op_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BinaryExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_op(static_cast<::milvus::proto::plan::BinaryExpr_BinaryOp>(val));
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr left = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_left(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr right = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(mutable_right(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BinaryExpr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.BinaryExpr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_op(static_cast< ::milvus::proto::plan::BinaryExpr_BinaryOp >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.Expr left = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_left()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.Expr right = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_right()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.BinaryExpr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.BinaryExpr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void BinaryExpr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.BinaryExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
  if (this->op() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->op(), output);
  }

  // .milvus.proto.plan.Expr left = 2;
  if (this->has_left()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, _Internal::left(this), output);
  }

  // .milvus.proto.plan.Expr right = 3;
  if (this->has_right()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, _Internal::right(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.BinaryExpr)
}

::PROTOBUF_NAMESPACE_ID::uint8* BinaryExpr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryExpr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
  if (this->op() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->op(), target);
  }

  // .milvus.proto.plan.Expr left = 2;
  if (this->has_left()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, _Internal::left(this), target);
  }

  // .milvus.proto.plan.Expr right = 3;
  if (this->has_right()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, _Internal::right(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryExpr)
  return target;
}

size_t BinaryExpr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.BinaryExpr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.Expr left = 2;
  if (this->has_left()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *left_);
  }

  // .milvus.proto.plan.Expr right = 3;
  if (this->has_right()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *right_);
  }

  // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
  if (this->op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->op());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BinaryExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.BinaryExpr)
  GOOGLE_DCHECK_NE(&from, this);
  const BinaryExpr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BinaryExpr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.BinaryExpr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.BinaryExpr)
    MergeFrom(*source);
  }
}

void BinaryExpr::MergeFrom(const BinaryExpr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryExpr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_left()) {
    mutable_left()->::milvus::proto::plan::Expr::MergeFrom(from.left());
  }
  if (from.has_right()) {
    mutable_right()->::milvus::proto::plan::Expr::MergeFrom(from.right());
  }
  if (from.op() != 0) {
    set_op(from.op());
  }
}

void BinaryExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.BinaryExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BinaryExpr::CopyFrom(const BinaryExpr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.BinaryExpr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BinaryExpr::IsInitialized() const {
  return true;
}

void BinaryExpr::InternalSwap(BinaryExpr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(left_, other->left_);
  swap(right_, other->right_);
  swap(op_, other->op_);
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryExpr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void Expr::InitAsDefaultInstance() {
  ::milvus::proto::plan::_Expr_default_instance_.term_expr_ = const_cast< ::milvus::proto::plan::TermExpr*>(
      ::milvus::proto::plan::TermExpr::internal_default_instance());
  ::milvus::proto::plan::_Expr_default_instance_.unary_expr_ = const_cast< ::milvus::proto::plan::UnaryExpr*>(
      ::milvus::proto::plan::UnaryExpr::internal_default_instance());
  ::milvus::proto::plan::_Expr_default_instance_.binary_expr_ = const_cast< ::milvus::proto::plan::BinaryExpr*>(
      ::milvus::proto::plan::BinaryExpr::internal_default_instance());
  ::milvus::proto::plan::_Expr_default_instance_.compare_expr_ = const_cast< ::milvus::proto::plan::CompareExpr*>(
      ::milvus::proto::plan::CompareExpr::internal_default_instance());
  ::milvus::proto::plan::_Expr_default_instance_.unary_range_expr_ = const_cast< ::milvus::proto::plan::UnaryRangeExpr*>(
      ::milvus::proto::plan::UnaryRangeExpr::internal_default_instance());
  ::milvus::proto::plan::_Expr_default_instance_.binary_range_expr_ = const_cast< ::milvus::proto::plan::BinaryRangeExpr*>(
      ::milvus::proto::plan::BinaryRangeExpr::internal_default_instance());
}
class Expr::_Internal {
 public:
  static const ::milvus::proto::plan::TermExpr& term_expr(const Expr* msg);
  static const ::milvus::proto::plan::UnaryExpr& unary_expr(const Expr* msg);
  static const ::milvus::proto::plan::BinaryExpr& binary_expr(const Expr* msg);
  static const ::milvus::proto::plan::CompareExpr& compare_expr(const Expr* msg);
  static const ::milvus::proto::plan::UnaryRangeExpr& unary_range_expr(const Expr* msg);
  static const ::milvus::proto::plan::BinaryRangeExpr& binary_range_expr(const Expr* msg);
};

const ::milvus::proto::plan::TermExpr&
Expr::_Internal::term_expr(const Expr* msg) {
  return *msg->expr_.term_expr_;
}
const ::milvus::proto::plan::UnaryExpr&
Expr::_Internal::unary_expr(const Expr* msg) {
  return *msg->expr_.unary_expr_;
}
const ::milvus::proto::plan::BinaryExpr&
Expr::_Internal::binary_expr(const Expr* msg) {
  return *msg->expr_.binary_expr_;
}
const ::milvus::proto::plan::CompareExpr&
Expr::_Internal::compare_expr(const Expr* msg) {
  return *msg->expr_.compare_expr_;
}
const ::milvus::proto::plan::UnaryRangeExpr&
Expr::_Internal::unary_range_expr(const Expr* msg) {
  return *msg->expr_.unary_range_expr_;
}
const ::milvus::proto::plan::BinaryRangeExpr&
Expr::_Internal::binary_range_expr(const Expr* msg) {
  return *msg->expr_.binary_range_expr_;
}
void Expr::set_allocated_term_expr(::milvus::proto::plan::TermExpr* term_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_expr();
  if (term_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      term_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, term_expr, submessage_arena);
    }
    set_has_term_expr();
    expr_.term_expr_ = term_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.term_expr)
}
void Expr::set_allocated_unary_expr(::milvus::proto::plan::UnaryExpr* unary_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_expr();
  if (unary_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      unary_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unary_expr, submessage_arena);
    }
    set_has_unary_expr();
    expr_.unary_expr_ = unary_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.unary_expr)
}
void Expr::set_allocated_binary_expr(::milvus::proto::plan::BinaryExpr* binary_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_expr();
  if (binary_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      binary_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary_expr, submessage_arena);
    }
    set_has_binary_expr();
    expr_.binary_expr_ = binary_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.binary_expr)
}
void Expr::set_allocated_compare_expr(::milvus::proto::plan::CompareExpr* compare_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_expr();
  if (compare_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      compare_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, compare_expr, submessage_arena);
    }
    set_has_compare_expr();
    expr_.compare_expr_ = compare_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.compare_expr)
}
void Expr::set_allocated_unary_range_expr(::milvus::proto::plan::UnaryRangeExpr* unary_range_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_expr();
  if (unary_range_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      unary_range_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unary_range_expr, submessage_arena);
    }
    set_has_unary_range_expr();
    expr_.unary_range_expr_ = unary_range_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.unary_range_expr)
}
void Expr::set_allocated_binary_range_expr(::milvus::proto::plan::BinaryRangeExpr* binary_range_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_expr();
  if (binary_range_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      binary_range_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary_range_expr, submessage_arena);
    }
    set_has_binary_range_expr();
    expr_.binary_range_expr_ = binary_range_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.binary_range_expr)
}
Expr::Expr()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.Expr)
}
Expr::Expr(const Expr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_expr();
  switch (from.expr_case()) {
    case kTermExpr: {
      mutable_term_expr()->::milvus::proto::plan::TermExpr::MergeFrom(from.term_expr());
      break;
    }
    case kUnaryExpr: {
      mutable_unary_expr()->::milvus::proto::plan::UnaryExpr::MergeFrom(from.unary_expr());
      break;
    }
    case kBinaryExpr: {
      mutable_binary_expr()->::milvus::proto::plan::BinaryExpr::MergeFrom(from.binary_expr());
      break;
    }
    case kCompareExpr: {
      mutable_compare_expr()->::milvus::proto::plan::CompareExpr::MergeFrom(from.compare_expr());
      break;
    }
    case kUnaryRangeExpr: {
      mutable_unary_range_expr()->::milvus::proto::plan::UnaryRangeExpr::MergeFrom(from.unary_range_expr());
      break;
    }
    case kBinaryRangeExpr: {
      mutable_binary_range_expr()->::milvus::proto::plan::BinaryRangeExpr::MergeFrom(from.binary_range_expr());
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.Expr)
}

void Expr::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinaryExpr_plan_2eproto.base);
  clear_has_expr();
}

Expr::~Expr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.Expr)
  SharedDtor();
}

void Expr::SharedDtor() {
  if (has_expr()) {
    clear_expr();
  }
}

void Expr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Expr& Expr::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinaryExpr_plan_2eproto.base);
  return *internal_default_instance();
}


void Expr::clear_expr() {
// @@protoc_insertion_point(one_of_clear_start:milvus.proto.plan.Expr)
  switch (expr_case()) {
    case kTermExpr: {
      delete expr_.term_expr_;
      break;
    }
    case kUnaryExpr: {
      delete expr_.unary_expr_;
      break;
    }
    case kBinaryExpr: {
      delete expr_.binary_expr_;
      break;
    }
    case kCompareExpr: {
      delete expr_.compare_expr_;
      break;
    }
    case kUnaryRangeExpr: {
      delete expr_.unary_range_expr_;
      break;
    }
    case kBinaryRangeExpr: {
      delete expr_.binary_range_expr_;
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EXPR_NOT_SET;
}


void Expr::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.Expr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_expr();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Expr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.TermExpr term_expr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_term_expr(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.UnaryExpr unary_expr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_unary_expr(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.BinaryExpr binary_expr = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(mutable_binary_expr(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.CompareExpr compare_expr = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(mutable_compare_expr(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_unary_range_expr(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(mutable_binary_range_expr(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Expr::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.Expr)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.TermExpr term_expr = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_term_expr()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.UnaryExpr unary_expr = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_unary_expr()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.BinaryExpr binary_expr = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_binary_expr()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.CompareExpr compare_expr = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_compare_expr()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_unary_range_expr()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_binary_range_expr()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.Expr)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.Expr)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void Expr::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.Expr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.TermExpr term_expr = 1;
  if (has_term_expr()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, _Internal::term_expr(this), output);
  }

  // .milvus.proto.plan.UnaryExpr unary_expr = 2;
  if (has_unary_expr()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, _Internal::unary_expr(this), output);
  }

  // .milvus.proto.plan.BinaryExpr binary_expr = 3;
  if (has_binary_expr()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, _Internal::binary_expr(this), output);
  }

  // .milvus.proto.plan.CompareExpr compare_expr = 4;
  if (has_compare_expr()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, _Internal::compare_expr(this), output);
  }

  // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
  if (has_unary_range_expr()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, _Internal::unary_range_expr(this), output);
  }

  // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
  if (has_binary_range_expr()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, _Internal::binary_range_expr(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.Expr)
}

::PROTOBUF_NAMESPACE_ID::uint8* Expr::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.Expr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.TermExpr term_expr = 1;
  if (has_term_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, _Internal::term_expr(this), target);
  }

  // .milvus.proto.plan.UnaryExpr unary_expr = 2;
  if (has_unary_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, _Internal::unary_expr(this), target);
  }

  // .milvus.proto.plan.BinaryExpr binary_expr = 3;
  if (has_binary_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, _Internal::binary_expr(this), target);
  }

  // .milvus.proto.plan.CompareExpr compare_expr = 4;
  if (has_compare_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, _Internal::compare_expr(this), target);
  }

  // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
  if (has_unary_range_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, _Internal::unary_range_expr(this), target);
  }

  // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
  if (has_binary_range_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, _Internal::binary_range_expr(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.Expr)
  return target;
}

size_t Expr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.Expr)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (expr_case()) {
    // .milvus.proto.plan.TermExpr term_expr = 1;
    case kTermExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *expr_.term_expr_);
      break;
    }
    // .milvus.proto.plan.UnaryExpr unary_expr = 2;
    case kUnaryExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *expr_.unary_expr_);
      break;
    }
    // .milvus.proto.plan.BinaryExpr binary_expr = 3;
    case kBinaryExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *expr_.binary_expr_);
      break;
    }
    // .milvus.proto.plan.CompareExpr compare_expr = 4;
    case kCompareExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *expr_.compare_expr_);
      break;
    }
    // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
    case kUnaryRangeExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *expr_.unary_range_expr_);
      break;
    }
    // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
    case kBinaryRangeExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *expr_.binary_range_expr_);
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Expr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.Expr)
  GOOGLE_DCHECK_NE(&from, this);
  const Expr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Expr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.Expr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.Expr)
    MergeFrom(*source);
  }
}

void Expr::MergeFrom(const Expr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.Expr)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.expr_case()) {
    case kTermExpr: {
      mutable_term_expr()->::milvus::proto::plan::TermExpr::MergeFrom(from.term_expr());
      break;
    }
    case kUnaryExpr: {
      mutable_unary_expr()->::milvus::proto::plan::UnaryExpr::MergeFrom(from.unary_expr());
      break;
    }
    case kBinaryExpr: {
      mutable_binary_expr()->::milvus::proto::plan::BinaryExpr::MergeFrom(from.binary_expr());
      break;
    }
    case kCompareExpr: {
      mutable_compare_expr()->::milvus::proto::plan::CompareExpr::MergeFrom(from.compare_expr());
      break;
    }
    case kUnaryRangeExpr: {
      mutable_unary_range_expr()->::milvus::proto::plan::UnaryRangeExpr::MergeFrom(from.unary_range_expr());
      break;
    }
    case kBinaryRangeExpr: {
      mutable_binary_range_expr()->::milvus::proto::plan::BinaryRangeExpr::MergeFrom(from.binary_range_expr());
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
}

void Expr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.Expr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Expr::CopyFrom(const Expr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.Expr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expr::IsInitialized() const {
  return true;
}

void Expr::InternalSwap(Expr* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(expr_, other->expr_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expr::GetMetadata() const {
  return GetMetadataStatic();
}


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

void VectorANNS::InitAsDefaultInstance() {
  ::milvus::proto::plan::_VectorANNS_default_instance_._instance.get_mutable()->predicates_ = const_cast< ::milvus::proto::plan::Expr*>(
      ::milvus::proto::plan::Expr::internal_default_instance());
  ::milvus::proto::plan::_VectorANNS_default_instance_._instance.get_mutable()->query_info_ = const_cast< ::milvus::proto::plan::QueryInfo*>(
      ::milvus::proto::plan::QueryInfo::internal_default_instance());
}
class VectorANNS::_Internal {
 public:
  static const ::milvus::proto::plan::Expr& predicates(const VectorANNS* msg);
  static const ::milvus::proto::plan::QueryInfo& query_info(const VectorANNS* msg);
};

const ::milvus::proto::plan::Expr&
VectorANNS::_Internal::predicates(const VectorANNS* msg) {
  return *msg->predicates_;
}
const ::milvus::proto::plan::QueryInfo&
VectorANNS::_Internal::query_info(const VectorANNS* msg) {
  return *msg->query_info_;
}
VectorANNS::VectorANNS()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.VectorANNS)
}
VectorANNS::VectorANNS(const VectorANNS& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  placeholder_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from.placeholder_tag().empty()) {
    placeholder_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.placeholder_tag_);
  }
  if (from.has_predicates()) {
    predicates_ = new ::milvus::proto::plan::Expr(*from.predicates_);
  } else {
    predicates_ = nullptr;
  }
  if (from.has_query_info()) {
    query_info_ = new ::milvus::proto::plan::QueryInfo(*from.query_info_);
  } else {
    query_info_ = nullptr;
  }
  ::memcpy(&field_id_, &from.field_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_binary_) -
    reinterpret_cast<char*>(&field_id_)) + sizeof(is_binary_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.VectorANNS)
}

void VectorANNS::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorANNS_plan_2eproto.base);
  placeholder_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&predicates_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_binary_) -
      reinterpret_cast<char*>(&predicates_)) + sizeof(is_binary_));
}

VectorANNS::~VectorANNS() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.VectorANNS)
  SharedDtor();
}

void VectorANNS::SharedDtor() {
  placeholder_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete predicates_;
  if (this != internal_default_instance()) delete query_info_;
}

void VectorANNS::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const VectorANNS& VectorANNS::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorANNS_plan_2eproto.base);
  return *internal_default_instance();
}


void VectorANNS::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.VectorANNS)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  placeholder_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == nullptr && predicates_ != nullptr) {
    delete predicates_;
  }
  predicates_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && query_info_ != nullptr) {
    delete query_info_;
  }
  query_info_ = nullptr;
  ::memset(&field_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_binary_) -
      reinterpret_cast<char*>(&field_id_)) + sizeof(is_binary_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* VectorANNS::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool is_binary = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          is_binary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int64 field_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          field_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr predicates = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(mutable_predicates(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .milvus.proto.plan.QueryInfo query_info = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(mutable_query_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string placeholder_tag = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_placeholder_tag(), ptr, ctx, "milvus.proto.plan.VectorANNS.placeholder_tag");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool VectorANNS::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.VectorANNS)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // bool is_binary = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_binary_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // int64 field_id = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, &field_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.Expr predicates = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_predicates()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .milvus.proto.plan.QueryInfo query_info = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_query_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string placeholder_tag = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_placeholder_tag()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->placeholder_tag().data(), static_cast<int>(this->placeholder_tag().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "milvus.proto.plan.VectorANNS.placeholder_tag"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.VectorANNS)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.VectorANNS)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void VectorANNS::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.VectorANNS)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool is_binary = 1;
  if (this->is_binary() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->is_binary(), output);
  }

  // int64 field_id = 2;
  if (this->field_id() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->field_id(), output);
  }

  // .milvus.proto.plan.Expr predicates = 3;
  if (this->has_predicates()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, _Internal::predicates(this), output);
  }

  // .milvus.proto.plan.QueryInfo query_info = 4;
  if (this->has_query_info()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, _Internal::query_info(this), output);
  }

  // string placeholder_tag = 5;
  if (this->placeholder_tag().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->placeholder_tag().data(), static_cast<int>(this->placeholder_tag().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.VectorANNS.placeholder_tag");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->placeholder_tag(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.VectorANNS)
}

::PROTOBUF_NAMESPACE_ID::uint8* VectorANNS::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.VectorANNS)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool is_binary = 1;
  if (this->is_binary() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->is_binary(), target);
  }

  // int64 field_id = 2;
  if (this->field_id() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->field_id(), target);
  }

  // .milvus.proto.plan.Expr predicates = 3;
  if (this->has_predicates()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, _Internal::predicates(this), target);
  }

  // .milvus.proto.plan.QueryInfo query_info = 4;
  if (this->has_query_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, _Internal::query_info(this), target);
  }

  // string placeholder_tag = 5;
  if (this->placeholder_tag().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->placeholder_tag().data(), static_cast<int>(this->placeholder_tag().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.VectorANNS.placeholder_tag");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        5, this->placeholder_tag(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.VectorANNS)
  return target;
}

size_t VectorANNS::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.VectorANNS)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string placeholder_tag = 5;
  if (this->placeholder_tag().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->placeholder_tag());
  }

  // .milvus.proto.plan.Expr predicates = 3;
  if (this->has_predicates()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *predicates_);
  }

  // .milvus.proto.plan.QueryInfo query_info = 4;
  if (this->has_query_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *query_info_);
  }

  // int64 field_id = 2;
  if (this->field_id() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->field_id());
  }

  // bool is_binary = 1;
  if (this->is_binary() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void VectorANNS::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.VectorANNS)
  GOOGLE_DCHECK_NE(&from, this);
  const VectorANNS* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<VectorANNS>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.VectorANNS)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.VectorANNS)
    MergeFrom(*source);
  }
}

void VectorANNS::MergeFrom(const VectorANNS& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.VectorANNS)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.placeholder_tag().size() > 0) {

    placeholder_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.placeholder_tag_);
  }
  if (from.has_predicates()) {
    mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(from.predicates());
  }
  if (from.has_query_info()) {
    mutable_query_info()->::milvus::proto::plan::QueryInfo::MergeFrom(from.query_info());
  }
  if (from.field_id() != 0) {
    set_field_id(from.field_id());
  }
  if (from.is_binary() != 0) {
    set_is_binary(from.is_binary());
  }
}

void VectorANNS::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.VectorANNS)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void VectorANNS::CopyFrom(const VectorANNS& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.VectorANNS)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool VectorANNS::IsInitialized() const {
  return true;
}

void VectorANNS::InternalSwap(VectorANNS* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  placeholder_tag_.Swap(&other->placeholder_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(predicates_, other->predicates_);
  swap(query_info_, other->query_info_);
  swap(field_id_, other->field_id_);
  swap(is_binary_, other->is_binary_);
}

::PROTOBUF_NAMESPACE_ID::Metadata VectorANNS::GetMetadata() const {
  return GetMetadataStatic();
}


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

void PlanNode::InitAsDefaultInstance() {
  ::milvus::proto::plan::_PlanNode_default_instance_.vector_anns_ = const_cast< ::milvus::proto::plan::VectorANNS*>(
      ::milvus::proto::plan::VectorANNS::internal_default_instance());
}
class PlanNode::_Internal {
 public:
  static const ::milvus::proto::plan::VectorANNS& vector_anns(const PlanNode* msg);
};

const ::milvus::proto::plan::VectorANNS&
PlanNode::_Internal::vector_anns(const PlanNode* msg) {
  return *msg->node_.vector_anns_;
}
void PlanNode::set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_node();
  if (vector_anns) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      vector_anns = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vector_anns, submessage_arena);
    }
    set_has_vector_anns();
    node_.vector_anns_ = vector_anns;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.vector_anns)
}
PlanNode::PlanNode()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:milvus.proto.plan.PlanNode)
}
PlanNode::PlanNode(const PlanNode& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      output_field_ids_(from.output_field_ids_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_node();
  switch (from.node_case()) {
    case kVectorAnns: {
      mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(from.vector_anns());
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.PlanNode)
}

void PlanNode::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PlanNode_plan_2eproto.base);
  clear_has_node();
}

PlanNode::~PlanNode() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.PlanNode)
  SharedDtor();
}

void PlanNode::SharedDtor() {
  if (has_node()) {
    clear_node();
  }
}

void PlanNode::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PlanNode& PlanNode::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PlanNode_plan_2eproto.base);
  return *internal_default_instance();
}


void PlanNode::clear_node() {
// @@protoc_insertion_point(one_of_clear_start:milvus.proto.plan.PlanNode)
  switch (node_case()) {
    case kVectorAnns: {
      delete node_.vector_anns_;
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = NODE_NOT_SET;
}


void PlanNode::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.PlanNode)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  output_field_ids_.Clear();
  clear_node();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* PlanNode::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .milvus.proto.plan.VectorANNS vector_anns = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_vector_anns(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int64 output_field_ids = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_output_field_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
          add_output_field_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool PlanNode::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:milvus.proto.plan.PlanNode)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .milvus.proto.plan.VectorANNS vector_anns = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_vector_anns()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated int64 output_field_ids = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_output_field_ids())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 1, 18u, input, this->mutable_output_field_ids())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:milvus.proto.plan.PlanNode)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:milvus.proto.plan.PlanNode)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void PlanNode::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:milvus.proto.plan.PlanNode)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.VectorANNS vector_anns = 1;
  if (has_vector_anns()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, _Internal::vector_anns(this), output);
  }

  // repeated int64 output_field_ids = 2;
  if (this->output_field_ids_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_output_field_ids_cached_byte_size_.load(
        std::memory_order_relaxed));
  }
  for (int i = 0, n = this->output_field_ids_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag(
      this->output_field_ids(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:milvus.proto.plan.PlanNode)
}

::PROTOBUF_NAMESPACE_ID::uint8* PlanNode::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.PlanNode)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.VectorANNS vector_anns = 1;
  if (has_vector_anns()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, _Internal::vector_anns(this), target);
  }

  // repeated int64 output_field_ids = 2;
  if (this->output_field_ids_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      2,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _output_field_ids_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteInt64NoTagToArray(this->output_field_ids_, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.PlanNode)
  return target;
}

size_t PlanNode::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.PlanNode)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int64 output_field_ids = 2;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int64Size(this->output_field_ids_);
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _output_field_ids_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  switch (node_case()) {
    // .milvus.proto.plan.VectorANNS vector_anns = 1;
    case kVectorAnns: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *node_.vector_anns_);
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PlanNode::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.PlanNode)
  GOOGLE_DCHECK_NE(&from, this);
  const PlanNode* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PlanNode>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.PlanNode)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.PlanNode)
    MergeFrom(*source);
  }
}

void PlanNode::MergeFrom(const PlanNode& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.PlanNode)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  output_field_ids_.MergeFrom(from.output_field_ids_);
  switch (from.node_case()) {
    case kVectorAnns: {
      mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(from.vector_anns());
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
}

void PlanNode::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.PlanNode)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PlanNode::CopyFrom(const PlanNode& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.plan.PlanNode)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlanNode::IsInitialized() const {
  return true;
}

void PlanNode::InternalSwap(PlanNode* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  output_field_ids_.InternalSwap(&other->output_field_ids_);
  swap(node_, other->node_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata PlanNode::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace plan
}  // namespace proto
}  // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::GenericValue* Arena::CreateMaybeMessage< ::milvus::proto::plan::GenericValue >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::GenericValue >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::QueryInfo* Arena::CreateMaybeMessage< ::milvus::proto::plan::QueryInfo >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::QueryInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::ColumnInfo* Arena::CreateMaybeMessage< ::milvus::proto::plan::ColumnInfo >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::ColumnInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::UnaryRangeExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::UnaryRangeExpr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::UnaryRangeExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryRangeExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryRangeExpr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::BinaryRangeExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::CompareExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::CompareExpr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::CompareExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::TermExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::TermExpr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::TermExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::UnaryExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::UnaryExpr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::UnaryExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryExpr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::BinaryExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::Expr* Arena::CreateMaybeMessage< ::milvus::proto::plan::Expr >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::Expr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::VectorANNS* Arena::CreateMaybeMessage< ::milvus::proto::plan::VectorANNS >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::VectorANNS >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::PlanNode* Arena::CreateMaybeMessage< ::milvus::proto::plan::PlanNode >(Arena* arena) {
  return Arena::CreateInternal< ::milvus::proto::plan::PlanNode >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>