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

#include "plan.pb.h"

#include <algorithm>

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

PROTOBUF_PRAGMA_INIT_SEG

namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;

namespace milvus {
namespace proto {
namespace plan {
PROTOBUF_CONSTEXPR GenericValue::GenericValue(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.val_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GenericValueDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GenericValueDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~GenericValueDefaultTypeInternal() {}
  union {
    GenericValue _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GenericValueDefaultTypeInternal _GenericValue_default_instance_;
PROTOBUF_CONSTEXPR Array::Array(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.array_)*/{}
  , /*decltype(_impl_.same_type_)*/false
  , /*decltype(_impl_.element_type_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ArrayDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ArrayDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ArrayDefaultTypeInternal() {}
  union {
    Array _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ArrayDefaultTypeInternal _Array_default_instance_;
PROTOBUF_CONSTEXPR QueryInfo::QueryInfo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.metric_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.search_params_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.topk_)*/int64_t{0}
  , /*decltype(_impl_.round_decimal_)*/int64_t{0}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct QueryInfoDefaultTypeInternal {
  PROTOBUF_CONSTEXPR QueryInfoDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~QueryInfoDefaultTypeInternal() {}
  union {
    QueryInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QueryInfoDefaultTypeInternal _QueryInfo_default_instance_;
PROTOBUF_CONSTEXPR ColumnInfo::ColumnInfo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.nested_path_)*/{}
  , /*decltype(_impl_.field_id_)*/int64_t{0}
  , /*decltype(_impl_.data_type_)*/0
  , /*decltype(_impl_.is_primary_key_)*/false
  , /*decltype(_impl_.is_autoid_)*/false
  , /*decltype(_impl_.is_partition_key_)*/false
  , /*decltype(_impl_.element_type_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ColumnInfoDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ColumnInfoDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ColumnInfoDefaultTypeInternal() {}
  union {
    ColumnInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ColumnInfoDefaultTypeInternal _ColumnInfo_default_instance_;
PROTOBUF_CONSTEXPR ColumnExpr::ColumnExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.info_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ColumnExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ColumnExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ColumnExprDefaultTypeInternal() {}
  union {
    ColumnExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ColumnExprDefaultTypeInternal _ColumnExpr_default_instance_;
PROTOBUF_CONSTEXPR ExistsExpr::ExistsExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.info_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ExistsExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ExistsExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ExistsExprDefaultTypeInternal() {}
  union {
    ExistsExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExistsExprDefaultTypeInternal _ExistsExpr_default_instance_;
PROTOBUF_CONSTEXPR ValueExpr::ValueExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.value_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ValueExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ValueExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ValueExprDefaultTypeInternal() {}
  union {
    ValueExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueExprDefaultTypeInternal _ValueExpr_default_instance_;
PROTOBUF_CONSTEXPR UnaryRangeExpr::UnaryRangeExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.column_info_)*/nullptr
  , /*decltype(_impl_.value_)*/nullptr
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct UnaryRangeExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR UnaryRangeExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~UnaryRangeExprDefaultTypeInternal() {}
  union {
    UnaryRangeExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnaryRangeExprDefaultTypeInternal _UnaryRangeExpr_default_instance_;
PROTOBUF_CONSTEXPR BinaryRangeExpr::BinaryRangeExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.column_info_)*/nullptr
  , /*decltype(_impl_.lower_value_)*/nullptr
  , /*decltype(_impl_.upper_value_)*/nullptr
  , /*decltype(_impl_.lower_inclusive_)*/false
  , /*decltype(_impl_.upper_inclusive_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct BinaryRangeExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BinaryRangeExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~BinaryRangeExprDefaultTypeInternal() {}
  union {
    BinaryRangeExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinaryRangeExprDefaultTypeInternal _BinaryRangeExpr_default_instance_;
PROTOBUF_CONSTEXPR CompareExpr::CompareExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.left_column_info_)*/nullptr
  , /*decltype(_impl_.right_column_info_)*/nullptr
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CompareExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CompareExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CompareExprDefaultTypeInternal() {}
  union {
    CompareExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompareExprDefaultTypeInternal _CompareExpr_default_instance_;
PROTOBUF_CONSTEXPR TermExpr::TermExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.values_)*/{}
  , /*decltype(_impl_.column_info_)*/nullptr
  , /*decltype(_impl_.is_in_field_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct TermExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TermExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~TermExprDefaultTypeInternal() {}
  union {
    TermExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TermExprDefaultTypeInternal _TermExpr_default_instance_;
PROTOBUF_CONSTEXPR JSONContainsExpr::JSONContainsExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.elements_)*/{}
  , /*decltype(_impl_.column_info_)*/nullptr
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_.elements_same_type_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct JSONContainsExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR JSONContainsExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~JSONContainsExprDefaultTypeInternal() {}
  union {
    JSONContainsExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JSONContainsExprDefaultTypeInternal _JSONContainsExpr_default_instance_;
PROTOBUF_CONSTEXPR UnaryExpr::UnaryExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.child_)*/nullptr
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct UnaryExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR UnaryExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~UnaryExprDefaultTypeInternal() {}
  union {
    UnaryExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnaryExprDefaultTypeInternal _UnaryExpr_default_instance_;
PROTOBUF_CONSTEXPR BinaryExpr::BinaryExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.left_)*/nullptr
  , /*decltype(_impl_.right_)*/nullptr
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct BinaryExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BinaryExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~BinaryExprDefaultTypeInternal() {}
  union {
    BinaryExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinaryExprDefaultTypeInternal _BinaryExpr_default_instance_;
PROTOBUF_CONSTEXPR BinaryArithOp::BinaryArithOp(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.column_info_)*/nullptr
  , /*decltype(_impl_.right_operand_)*/nullptr
  , /*decltype(_impl_.arith_op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct BinaryArithOpDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BinaryArithOpDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~BinaryArithOpDefaultTypeInternal() {}
  union {
    BinaryArithOp _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinaryArithOpDefaultTypeInternal _BinaryArithOp_default_instance_;
PROTOBUF_CONSTEXPR BinaryArithExpr::BinaryArithExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.left_)*/nullptr
  , /*decltype(_impl_.right_)*/nullptr
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct BinaryArithExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BinaryArithExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~BinaryArithExprDefaultTypeInternal() {}
  union {
    BinaryArithExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinaryArithExprDefaultTypeInternal _BinaryArithExpr_default_instance_;
PROTOBUF_CONSTEXPR BinaryArithOpEvalRangeExpr::BinaryArithOpEvalRangeExpr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.column_info_)*/nullptr
  , /*decltype(_impl_.right_operand_)*/nullptr
  , /*decltype(_impl_.value_)*/nullptr
  , /*decltype(_impl_.arith_op_)*/0
  , /*decltype(_impl_.op_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct BinaryArithOpEvalRangeExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BinaryArithOpEvalRangeExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~BinaryArithOpEvalRangeExprDefaultTypeInternal() {}
  union {
    BinaryArithOpEvalRangeExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinaryArithOpEvalRangeExprDefaultTypeInternal _BinaryArithOpEvalRangeExpr_default_instance_;
PROTOBUF_CONSTEXPR AlwaysTrueExpr::AlwaysTrueExpr(
    ::_pbi::ConstantInitialized) {}
struct AlwaysTrueExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AlwaysTrueExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~AlwaysTrueExprDefaultTypeInternal() {}
  union {
    AlwaysTrueExpr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AlwaysTrueExprDefaultTypeInternal _AlwaysTrueExpr_default_instance_;
PROTOBUF_CONSTEXPR Expr::Expr(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.expr_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct ExprDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ExprDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ExprDefaultTypeInternal() {}
  union {
    Expr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExprDefaultTypeInternal _Expr_default_instance_;
PROTOBUF_CONSTEXPR VectorANNS::VectorANNS(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.placeholder_tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.predicates_)*/nullptr
  , /*decltype(_impl_.query_info_)*/nullptr
  , /*decltype(_impl_.field_id_)*/int64_t{0}
  , /*decltype(_impl_.vector_type_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct VectorANNSDefaultTypeInternal {
  PROTOBUF_CONSTEXPR VectorANNSDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~VectorANNSDefaultTypeInternal() {}
  union {
    VectorANNS _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VectorANNSDefaultTypeInternal _VectorANNS_default_instance_;
PROTOBUF_CONSTEXPR QueryPlanNode::QueryPlanNode(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.predicates_)*/nullptr
  , /*decltype(_impl_.limit_)*/int64_t{0}
  , /*decltype(_impl_.is_count_)*/false
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct QueryPlanNodeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR QueryPlanNodeDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~QueryPlanNodeDefaultTypeInternal() {}
  union {
    QueryPlanNode _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QueryPlanNodeDefaultTypeInternal _QueryPlanNode_default_instance_;
PROTOBUF_CONSTEXPR PlanNode::PlanNode(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.output_field_ids_)*/{}
  , /*decltype(_impl_._output_field_ids_cached_byte_size_)*/{0}
  , /*decltype(_impl_.node_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PlanNodeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PlanNodeDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~PlanNodeDefaultTypeInternal() {}
  union {
    PlanNode _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PlanNodeDefaultTypeInternal _PlanNode_default_instance_;
}  // namespace plan
}  // namespace proto
}  // namespace milvus
static ::_pb::Metadata file_level_metadata_plan_2eproto[22];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_plan_2eproto[6];
static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_plan_2eproto = nullptr;

const uint32_t 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, _impl_._oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::GenericValue, _impl_.val_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Array, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Array, _impl_.array_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Array, _impl_.same_type_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Array, _impl_.element_type_),
  ~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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, _impl_.topk_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, _impl_.metric_type_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, _impl_.search_params_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryInfo, _impl_.round_decimal_),
  ~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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.field_id_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.data_type_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.is_primary_key_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.is_autoid_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.nested_path_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.is_partition_key_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnInfo, _impl_.element_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ColumnExpr, _impl_.info_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ExistsExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ExistsExpr, _impl_.info_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ValueExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::ValueExpr, _impl_.value_),
  ~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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, _impl_.column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, _impl_.op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryRangeExpr, _impl_.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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, _impl_.column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, _impl_.lower_inclusive_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, _impl_.upper_inclusive_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, _impl_.lower_value_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryRangeExpr, _impl_.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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, _impl_.left_column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, _impl_.right_column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::CompareExpr, _impl_.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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::TermExpr, _impl_.column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::TermExpr, _impl_.values_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::TermExpr, _impl_.is_in_field_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::JSONContainsExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::JSONContainsExpr, _impl_.column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::JSONContainsExpr, _impl_.elements_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::JSONContainsExpr, _impl_.op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::JSONContainsExpr, _impl_.elements_same_type_),
  ~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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryExpr, _impl_.op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::UnaryExpr, _impl_.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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, _impl_.op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, _impl_.left_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, _impl_.right_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, _impl_.column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, _impl_.arith_op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, _impl_.right_operand_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithExpr, _impl_.left_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithExpr, _impl_.right_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithExpr, _impl_.op_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, _impl_.column_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, _impl_.arith_op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, _impl_.right_operand_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, _impl_.op_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, _impl_.value_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::AlwaysTrueExpr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _impl_._oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _impl_.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_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _impl_.vector_type_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _impl_.field_id_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _impl_.predicates_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _impl_.query_info_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _impl_.placeholder_tag_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryPlanNode, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryPlanNode, _impl_.predicates_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryPlanNode, _impl_.is_count_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::QueryPlanNode, _impl_.limit_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _impl_._oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  ::_pbi::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _impl_.output_field_ids_),
  PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _impl_.node_),
};
static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, -1, sizeof(::milvus::proto::plan::GenericValue)},
  { 12, -1, -1, sizeof(::milvus::proto::plan::Array)},
  { 21, -1, -1, sizeof(::milvus::proto::plan::QueryInfo)},
  { 31, -1, -1, sizeof(::milvus::proto::plan::ColumnInfo)},
  { 44, -1, -1, sizeof(::milvus::proto::plan::ColumnExpr)},
  { 51, -1, -1, sizeof(::milvus::proto::plan::ExistsExpr)},
  { 58, -1, -1, sizeof(::milvus::proto::plan::ValueExpr)},
  { 65, -1, -1, sizeof(::milvus::proto::plan::UnaryRangeExpr)},
  { 74, -1, -1, sizeof(::milvus::proto::plan::BinaryRangeExpr)},
  { 85, -1, -1, sizeof(::milvus::proto::plan::CompareExpr)},
  { 94, -1, -1, sizeof(::milvus::proto::plan::TermExpr)},
  { 103, -1, -1, sizeof(::milvus::proto::plan::JSONContainsExpr)},
  { 113, -1, -1, sizeof(::milvus::proto::plan::UnaryExpr)},
  { 121, -1, -1, sizeof(::milvus::proto::plan::BinaryExpr)},
  { 130, -1, -1, sizeof(::milvus::proto::plan::BinaryArithOp)},
  { 139, -1, -1, sizeof(::milvus::proto::plan::BinaryArithExpr)},
  { 148, -1, -1, sizeof(::milvus::proto::plan::BinaryArithOpEvalRangeExpr)},
  { 159, -1, -1, sizeof(::milvus::proto::plan::AlwaysTrueExpr)},
  { 165, -1, -1, sizeof(::milvus::proto::plan::Expr)},
  { 185, -1, -1, sizeof(::milvus::proto::plan::VectorANNS)},
  { 196, -1, -1, sizeof(::milvus::proto::plan::QueryPlanNode)},
  { 205, -1, -1, sizeof(::milvus::proto::plan::PlanNode)},
};

static const ::_pb::Message* const file_default_instances[] = {
  &::milvus::proto::plan::_GenericValue_default_instance_._instance,
  &::milvus::proto::plan::_Array_default_instance_._instance,
  &::milvus::proto::plan::_QueryInfo_default_instance_._instance,
  &::milvus::proto::plan::_ColumnInfo_default_instance_._instance,
  &::milvus::proto::plan::_ColumnExpr_default_instance_._instance,
  &::milvus::proto::plan::_ExistsExpr_default_instance_._instance,
  &::milvus::proto::plan::_ValueExpr_default_instance_._instance,
  &::milvus::proto::plan::_UnaryRangeExpr_default_instance_._instance,
  &::milvus::proto::plan::_BinaryRangeExpr_default_instance_._instance,
  &::milvus::proto::plan::_CompareExpr_default_instance_._instance,
  &::milvus::proto::plan::_TermExpr_default_instance_._instance,
  &::milvus::proto::plan::_JSONContainsExpr_default_instance_._instance,
  &::milvus::proto::plan::_UnaryExpr_default_instance_._instance,
  &::milvus::proto::plan::_BinaryExpr_default_instance_._instance,
  &::milvus::proto::plan::_BinaryArithOp_default_instance_._instance,
  &::milvus::proto::plan::_BinaryArithExpr_default_instance_._instance,
  &::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_._instance,
  &::milvus::proto::plan::_AlwaysTrueExpr_default_instance_._instance,
  &::milvus::proto::plan::_Expr_default_instance_._instance,
  &::milvus::proto::plan::_VectorANNS_default_instance_._instance,
  &::milvus::proto::plan::_QueryPlanNode_default_instance_._instance,
  &::milvus::proto::plan::_PlanNode_default_instance_._instance,
};

const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\nplan.proto\022\021milvus.proto.plan\032\014schema."
  "proto\"\230\001\n\014GenericValue\022\022\n\010bool_val\030\001 \001(\010"
  "H\000\022\023\n\tint64_val\030\002 \001(\003H\000\022\023\n\tfloat_val\030\003 \001"
  "(\001H\000\022\024\n\nstring_val\030\004 \001(\tH\000\022-\n\tarray_val\030"
  "\005 \001(\0132\030.milvus.proto.plan.ArrayH\000B\005\n\003val"
  "\"\177\n\005Array\022.\n\005array\030\001 \003(\0132\037.milvus.proto."
  "plan.GenericValue\022\021\n\tsame_type\030\002 \001(\010\0223\n\014"
  "element_type\030\003 \001(\0162\035.milvus.proto.schema"
  ".DataType\"\\\n\tQueryInfo\022\014\n\004topk\030\001 \001(\003\022\023\n\013"
  "metric_type\030\003 \001(\t\022\025\n\rsearch_params\030\004 \001(\t"
  "\022\025\n\rround_decimal\030\005 \001(\003\"\337\001\n\nColumnInfo\022\020"
  "\n\010field_id\030\001 \001(\003\0220\n\tdata_type\030\002 \001(\0162\035.mi"
  "lvus.proto.schema.DataType\022\026\n\016is_primary"
  "_key\030\003 \001(\010\022\021\n\tis_autoID\030\004 \001(\010\022\023\n\013nested_"
  "path\030\005 \003(\t\022\030\n\020is_partition_key\030\006 \001(\010\0223\n\014"
  "element_type\030\007 \001(\0162\035.milvus.proto.schema"
  ".DataType\"9\n\nColumnExpr\022+\n\004info\030\001 \001(\0132\035."
  "milvus.proto.plan.ColumnInfo\"9\n\nExistsEx"
  "pr\022+\n\004info\030\001 \001(\0132\035.milvus.proto.plan.Col"
  "umnInfo\";\n\tValueExpr\022.\n\005value\030\001 \001(\0132\037.mi"
  "lvus.proto.plan.GenericValue\"\233\001\n\016UnaryRa"
  "ngeExpr\0222\n\013column_info\030\001 \001(\0132\035.milvus.pr"
  "oto.plan.ColumnInfo\022%\n\002op\030\002 \001(\0162\031.milvus"
  ".proto.plan.OpType\022.\n\005value\030\003 \001(\0132\037.milv"
  "us.proto.plan.GenericValue\"\343\001\n\017BinaryRan"
  "geExpr\0222\n\013column_info\030\001 \001(\0132\035.milvus.pro"
  "to.plan.ColumnInfo\022\027\n\017lower_inclusive\030\002 "
  "\001(\010\022\027\n\017upper_inclusive\030\003 \001(\010\0224\n\013lower_va"
  "lue\030\004 \001(\0132\037.milvus.proto.plan.GenericVal"
  "ue\0224\n\013upper_value\030\005 \001(\0132\037.milvus.proto.p"
  "lan.GenericValue\"\247\001\n\013CompareExpr\0227\n\020left"
  "_column_info\030\001 \001(\0132\035.milvus.proto.plan.C"
  "olumnInfo\0228\n\021right_column_info\030\002 \001(\0132\035.m"
  "ilvus.proto.plan.ColumnInfo\022%\n\002op\030\003 \001(\0162"
  "\031.milvus.proto.plan.OpType\"\204\001\n\010TermExpr\022"
  "2\n\013column_info\030\001 \001(\0132\035.milvus.proto.plan"
  ".ColumnInfo\022/\n\006values\030\002 \003(\0132\037.milvus.pro"
  "to.plan.GenericValue\022\023\n\013is_in_field\030\003 \001("
  "\010\"\224\002\n\020JSONContainsExpr\0222\n\013column_info\030\001 "
  "\001(\0132\035.milvus.proto.plan.ColumnInfo\0221\n\010el"
  "ements\030\002 \003(\0132\037.milvus.proto.plan.Generic"
  "Value\0226\n\002op\030\003 \001(\0162*.milvus.proto.plan.JS"
  "ONContainsExpr.JSONOp\022\032\n\022elements_same_t"
  "ype\030\004 \001(\010\"E\n\006JSONOp\022\013\n\007Invalid\020\000\022\014\n\010Cont"
  "ains\020\001\022\017\n\013ContainsAll\020\002\022\017\n\013ContainsAny\020\003"
  "\"\206\001\n\tUnaryExpr\0220\n\002op\030\001 \001(\0162$.milvus.prot"
  "o.plan.UnaryExpr.UnaryOp\022&\n\005child\030\002 \001(\0132"
  "\027.milvus.proto.plan.Expr\"\037\n\007UnaryOp\022\013\n\007I"
  "nvalid\020\000\022\007\n\003Not\020\001\"\307\001\n\nBinaryExpr\0222\n\002op\030\001"
  " \001(\0162&.milvus.proto.plan.BinaryExpr.Bina"
  "ryOp\022%\n\004left\030\002 \001(\0132\027.milvus.proto.plan.E"
  "xpr\022&\n\005right\030\003 \001(\0132\027.milvus.proto.plan.E"
  "xpr\"6\n\010BinaryOp\022\013\n\007Invalid\020\000\022\016\n\nLogicalA"
  "nd\020\001\022\r\n\tLogicalOr\020\002\"\255\001\n\rBinaryArithOp\0222\n"
  "\013column_info\030\001 \001(\0132\035.milvus.proto.plan.C"
  "olumnInfo\0220\n\010arith_op\030\002 \001(\0162\036.milvus.pro"
  "to.plan.ArithOpType\0226\n\rright_operand\030\003 \001"
  "(\0132\037.milvus.proto.plan.GenericValue\"\214\001\n\017"
  "BinaryArithExpr\022%\n\004left\030\001 \001(\0132\027.milvus.p"
  "roto.plan.Expr\022&\n\005right\030\002 \001(\0132\027.milvus.p"
  "roto.plan.Expr\022*\n\002op\030\003 \001(\0162\036.milvus.prot"
  "o.plan.ArithOpType\"\221\002\n\032BinaryArithOpEval"
  "RangeExpr\0222\n\013column_info\030\001 \001(\0132\035.milvus."
  "proto.plan.ColumnInfo\0220\n\010arith_op\030\002 \001(\0162"
  "\036.milvus.proto.plan.ArithOpType\0226\n\rright"
  "_operand\030\003 \001(\0132\037.milvus.proto.plan.Gener"
  "icValue\022%\n\002op\030\004 \001(\0162\031.milvus.proto.plan."
  "OpType\022.\n\005value\030\005 \001(\0132\037.milvus.proto.pla"
  "n.GenericValue\"\020\n\016AlwaysTrueExpr\"\237\006\n\004Exp"
  "r\0220\n\tterm_expr\030\001 \001(\0132\033.milvus.proto.plan"
  ".TermExprH\000\0222\n\nunary_expr\030\002 \001(\0132\034.milvus"
  ".proto.plan.UnaryExprH\000\0224\n\013binary_expr\030\003"
  " \001(\0132\035.milvus.proto.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.plan.UnaryRangeExprH\000\022\?\n\021"
  "binary_range_expr\030\006 \001(\0132\".milvus.proto.p"
  "lan.BinaryRangeExprH\000\022X\n\037binary_arith_op"
  "_eval_range_expr\030\007 \001(\0132-.milvus.proto.pl"
  "an.BinaryArithOpEvalRangeExprH\000\022\?\n\021binar"
  "y_arith_expr\030\010 \001(\0132\".milvus.proto.plan.B"
  "inaryArithExprH\000\0222\n\nvalue_expr\030\t \001(\0132\034.m"
  "ilvus.proto.plan.ValueExprH\000\0224\n\013column_e"
  "xpr\030\n \001(\0132\035.milvus.proto.plan.ColumnExpr"
  "H\000\0224\n\013exists_expr\030\013 \001(\0132\035.milvus.proto.p"
  "lan.ExistsExprH\000\022=\n\020always_true_expr\030\014 \001"
  "(\0132!.milvus.proto.plan.AlwaysTrueExprH\000\022"
  "A\n\022json_contains_expr\030\r \001(\0132#.milvus.pro"
  "to.plan.JSONContainsExprH\000B\006\n\004expr\"\312\001\n\nV"
  "ectorANNS\0222\n\013vector_type\030\001 \001(\0162\035.milvus."
  "proto.plan.VectorType\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\""
  "]\n\rQueryPlanNode\022+\n\npredicates\030\001 \001(\0132\027.m"
  "ilvus.proto.plan.Expr\022\020\n\010is_count\030\002 \001(\010\022"
  "\r\n\005limit\030\003 \001(\003\"\304\001\n\010PlanNode\0224\n\013vector_an"
  "ns\030\001 \001(\0132\035.milvus.proto.plan.VectorANNSH"
  "\000\022-\n\npredicates\030\002 \001(\0132\027.milvus.proto.pla"
  "n.ExprH\000\0221\n\005query\030\004 \001(\0132 .milvus.proto.p"
  "lan.QueryPlanNodeH\000\022\030\n\020output_field_ids\030"
  "\003 \003(\003B\006\n\004node*\272\001\n\006OpType\022\013\n\007Invalid\020\000\022\017\n"
  "\013GreaterThan\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010Less"
  "Than\020\003\022\r\n\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010NotE"
  "qual\020\006\022\017\n\013PrefixMatch\020\007\022\020\n\014PostfixMatch\020"
  "\010\022\t\n\005Match\020\t\022\t\n\005Range\020\n\022\006\n\002In\020\013\022\t\n\005NotIn"
  "\020\014*X\n\013ArithOpType\022\013\n\007Unknown\020\000\022\007\n\003Add\020\001\022"
  "\007\n\003Sub\020\002\022\007\n\003Mul\020\003\022\007\n\003Div\020\004\022\007\n\003Mod\020\005\022\017\n\013A"
  "rrayLength\020\006*B\n\nVectorType\022\020\n\014BinaryVect"
  "or\020\000\022\017\n\013FloatVector\020\001\022\021\n\rFloat16Vector\020\002"
  "B3Z1github.com/milvus-io/milvus/internal"
  "/proto/planpbb\006proto3"
  ;
static const ::_pbi::DescriptorTable* const descriptor_table_plan_2eproto_deps[1] = {
  &::descriptor_table_schema_2eproto,
};
static ::_pbi::once_flag descriptor_table_plan_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_plan_2eproto = {
    false, false, 4461, descriptor_table_protodef_plan_2eproto,
    "plan.proto",
    &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_deps, 1, 22,
    schemas, file_default_instances, TableStruct_plan_2eproto::offsets,
    file_level_metadata_plan_2eproto, file_level_enum_descriptors_plan_2eproto,
    file_level_service_descriptors_plan_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_plan_2eproto_getter() {
  return &descriptor_table_plan_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_plan_2eproto(&descriptor_table_plan_2eproto);
namespace milvus {
namespace proto {
namespace plan {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JSONContainsExpr_JSONOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[0];
}
bool JSONContainsExpr_JSONOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr JSONContainsExpr_JSONOp JSONContainsExpr::Invalid;
constexpr JSONContainsExpr_JSONOp JSONContainsExpr::Contains;
constexpr JSONContainsExpr_JSONOp JSONContainsExpr::ContainsAll;
constexpr JSONContainsExpr_JSONOp JSONContainsExpr::ContainsAny;
constexpr JSONContainsExpr_JSONOp JSONContainsExpr::JSONOp_MIN;
constexpr JSONContainsExpr_JSONOp JSONContainsExpr::JSONOp_MAX;
constexpr int JSONContainsExpr::JSONOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* UnaryExpr_UnaryOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[1];
}
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 && _MSC_VER < 1912))
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 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BinaryExpr_BinaryOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[2];
}
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 && _MSC_VER < 1912))
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 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[3];
}
bool OpType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ArithOpType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[4];
}
bool ArithOpType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VectorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto);
  return file_level_enum_descriptors_plan_2eproto[5];
}
bool VectorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


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

class GenericValue::_Internal {
 public:
  static const ::milvus::proto::plan::Array& array_val(const GenericValue* msg);
};

const ::milvus::proto::plan::Array&
GenericValue::_Internal::array_val(const GenericValue* msg) {
  return *msg->_impl_.val_.array_val_;
}
void GenericValue::set_allocated_array_val(::milvus::proto::plan::Array* array_val) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_val();
  if (array_val) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(array_val);
    if (message_arena != submessage_arena) {
      array_val = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, array_val, submessage_arena);
    }
    set_has_array_val();
    _impl_.val_.array_val_ = array_val;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.GenericValue.array_val)
}
GenericValue::GenericValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.GenericValue)
}
GenericValue::GenericValue(const GenericValue& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  GenericValue* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.val_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_val();
  switch (from.val_case()) {
    case kBoolVal: {
      _this->_internal_set_bool_val(from._internal_bool_val());
      break;
    }
    case kInt64Val: {
      _this->_internal_set_int64_val(from._internal_int64_val());
      break;
    }
    case kFloatVal: {
      _this->_internal_set_float_val(from._internal_float_val());
      break;
    }
    case kStringVal: {
      _this->_internal_set_string_val(from._internal_string_val());
      break;
    }
    case kArrayVal: {
      _this->_internal_mutable_array_val()->::milvus::proto::plan::Array::MergeFrom(
          from._internal_array_val());
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.GenericValue)
}

inline void GenericValue::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.val_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_val();
}

GenericValue::~GenericValue() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.GenericValue)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GenericValue::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_val()) {
    clear_val();
  }
}

void GenericValue::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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 kStringVal: {
      _impl_.val_.string_val_.Destroy();
      break;
    }
    case kArrayVal: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.val_.array_val_;
      }
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = VAL_NOT_SET;
}


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

  clear_val();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* GenericValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bool bool_val = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _internal_set_bool_val(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 int64_val = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _internal_set_int64_val(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // double float_val = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _internal_set_float_val(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // string string_val = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_string_val();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, "milvus.proto.plan.GenericValue.string_val"));
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.Array array_val = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_array_val(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* GenericValue::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.GenericValue)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool bool_val = 1;
  if (_internal_has_bool_val()) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_bool_val(), target);
  }

  // int64 int64_val = 2;
  if (_internal_has_int64_val()) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_int64_val(), target);
  }

  // double float_val = 3;
  if (_internal_has_float_val()) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_float_val(), target);
  }

  // string string_val = 4;
  if (_internal_has_string_val()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_string_val().data(), static_cast<int>(this->_internal_string_val().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.GenericValue.string_val");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_string_val(), target);
  }

  // .milvus.proto.plan.Array array_val = 5;
  if (_internal_has_array_val()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::array_val(this),
        _Internal::array_val(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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 += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_int64_val());
      break;
    }
    // double float_val = 3;
    case kFloatVal: {
      total_size += 1 + 8;
      break;
    }
    // string string_val = 4;
    case kStringVal: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_string_val());
      break;
    }
    // .milvus.proto.plan.Array array_val = 5;
    case kArrayVal: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.val_.array_val_);
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GenericValue::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    GenericValue::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GenericValue::GetClassData() const { return &_class_data_; }


void GenericValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<GenericValue*>(&to_msg);
  auto& from = static_cast<const GenericValue&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.GenericValue)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.val_case()) {
    case kBoolVal: {
      _this->_internal_set_bool_val(from._internal_bool_val());
      break;
    }
    case kInt64Val: {
      _this->_internal_set_int64_val(from._internal_int64_val());
      break;
    }
    case kFloatVal: {
      _this->_internal_set_float_val(from._internal_float_val());
      break;
    }
    case kStringVal: {
      _this->_internal_set_string_val(from._internal_string_val());
      break;
    }
    case kArrayVal: {
      _this->_internal_mutable_array_val()->::milvus::proto::plan::Array::MergeFrom(
          from._internal_array_val());
      break;
    }
    case VAL_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.val_, other->_impl_.val_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata GenericValue::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[0]);
}

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

class Array::_Internal {
 public:
};

Array::Array(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.Array)
}
Array::Array(const Array& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  Array* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.array_){from._impl_.array_}
    , decltype(_impl_.same_type_){}
    , decltype(_impl_.element_type_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&_impl_.same_type_, &from._impl_.same_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.element_type_) -
    reinterpret_cast<char*>(&_impl_.same_type_)) + sizeof(_impl_.element_type_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.Array)
}

inline void Array::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.array_){arena}
    , decltype(_impl_.same_type_){false}
    , decltype(_impl_.element_type_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

Array::~Array() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.Array)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Array::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.array_.~RepeatedPtrField();
}

void Array::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  _impl_.array_.Clear();
  ::memset(&_impl_.same_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.element_type_) -
      reinterpret_cast<char*>(&_impl_.same_type_)) + sizeof(_impl_.element_type_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Array::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .milvus.proto.plan.GenericValue array = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_array(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // bool same_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _impl_.same_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.schema.DataType element_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_element_type(static_cast<::milvus::proto::schema::DataType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* Array::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.Array)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .milvus.proto.plan.GenericValue array = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_array_size()); i < n; i++) {
    const auto& repfield = this->_internal_array(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

  // bool same_type = 2;
  if (this->_internal_same_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_same_type(), target);
  }

  // .milvus.proto.schema.DataType element_type = 3;
  if (this->_internal_element_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      3, this->_internal_element_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.Array)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .milvus.proto.plan.GenericValue array = 1;
  total_size += 1UL * this->_internal_array_size();
  for (const auto& msg : this->_impl_.array_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

  // .milvus.proto.schema.DataType element_type = 3;
  if (this->_internal_element_type() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_element_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Array::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    Array::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Array::GetClassData() const { return &_class_data_; }


void Array::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<Array*>(&to_msg);
  auto& from = static_cast<const Array&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.Array)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.array_.MergeFrom(from._impl_.array_);
  if (from._internal_same_type() != 0) {
    _this->_internal_set_same_type(from._internal_same_type());
  }
  if (from._internal_element_type() != 0) {
    _this->_internal_set_element_type(from._internal_element_type());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Array::InternalSwap(Array* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.array_.InternalSwap(&other->_impl_.array_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Array, _impl_.element_type_)
      + sizeof(Array::_impl_.element_type_)
      - PROTOBUF_FIELD_OFFSET(Array, _impl_.same_type_)>(
          reinterpret_cast<char*>(&_impl_.same_type_),
          reinterpret_cast<char*>(&other->_impl_.same_type_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Array::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[1]);
}

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

class QueryInfo::_Internal {
 public:
};

QueryInfo::QueryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.QueryInfo)
}
QueryInfo::QueryInfo(const QueryInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  QueryInfo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.metric_type_){}
    , decltype(_impl_.search_params_){}
    , decltype(_impl_.topk_){}
    , decltype(_impl_.round_decimal_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.metric_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.metric_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_metric_type().empty()) {
    _this->_impl_.metric_type_.Set(from._internal_metric_type(), 
      _this->GetArenaForAllocation());
  }
  _impl_.search_params_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.search_params_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_search_params().empty()) {
    _this->_impl_.search_params_.Set(from._internal_search_params(), 
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.topk_, &from._impl_.topk_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.round_decimal_) -
    reinterpret_cast<char*>(&_impl_.topk_)) + sizeof(_impl_.round_decimal_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.QueryInfo)
}

inline void QueryInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.metric_type_){}
    , decltype(_impl_.search_params_){}
    , decltype(_impl_.topk_){int64_t{0}}
    , decltype(_impl_.round_decimal_){int64_t{0}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.metric_type_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.metric_type_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.search_params_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.search_params_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

QueryInfo::~QueryInfo() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.QueryInfo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void QueryInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.metric_type_.Destroy();
  _impl_.search_params_.Destroy();
}

void QueryInfo::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  _impl_.metric_type_.ClearToEmpty();
  _impl_.search_params_.ClearToEmpty();
  ::memset(&_impl_.topk_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.round_decimal_) -
      reinterpret_cast<char*>(&_impl_.topk_)) + sizeof(_impl_.round_decimal_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* QueryInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 topk = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _impl_.topk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string metric_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_metric_type();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, "milvus.proto.plan.QueryInfo.metric_type"));
        } else
          goto handle_unusual;
        continue;
      // string search_params = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_search_params();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, "milvus.proto.plan.QueryInfo.search_params"));
        } else
          goto handle_unusual;
        continue;
      // int64 round_decimal = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _impl_.round_decimal_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* QueryInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.QueryInfo)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 topk = 1;
  if (this->_internal_topk() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_topk(), target);
  }

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

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

  // int64 round_decimal = 5;
  if (this->_internal_round_decimal() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_round_decimal(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

  // int64 topk = 1;
  if (this->_internal_topk() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_topk());
  }

  // int64 round_decimal = 5;
  if (this->_internal_round_decimal() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_round_decimal());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData QueryInfo::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    QueryInfo::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*QueryInfo::GetClassData() const { return &_class_data_; }


void QueryInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<QueryInfo*>(&to_msg);
  auto& from = static_cast<const QueryInfo&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.QueryInfo)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_metric_type().empty()) {
    _this->_internal_set_metric_type(from._internal_metric_type());
  }
  if (!from._internal_search_params().empty()) {
    _this->_internal_set_search_params(from._internal_search_params());
  }
  if (from._internal_topk() != 0) {
    _this->_internal_set_topk(from._internal_topk());
  }
  if (from._internal_round_decimal() != 0) {
    _this->_internal_set_round_decimal(from._internal_round_decimal());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.metric_type_, lhs_arena,
      &other->_impl_.metric_type_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.search_params_, lhs_arena,
      &other->_impl_.search_params_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(QueryInfo, _impl_.round_decimal_)
      + sizeof(QueryInfo::_impl_.round_decimal_)
      - PROTOBUF_FIELD_OFFSET(QueryInfo, _impl_.topk_)>(
          reinterpret_cast<char*>(&_impl_.topk_),
          reinterpret_cast<char*>(&other->_impl_.topk_));
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryInfo::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[2]);
}

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

class ColumnInfo::_Internal {
 public:
};

ColumnInfo::ColumnInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.ColumnInfo)
}
ColumnInfo::ColumnInfo(const ColumnInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  ColumnInfo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.nested_path_){from._impl_.nested_path_}
    , decltype(_impl_.field_id_){}
    , decltype(_impl_.data_type_){}
    , decltype(_impl_.is_primary_key_){}
    , decltype(_impl_.is_autoid_){}
    , decltype(_impl_.is_partition_key_){}
    , decltype(_impl_.element_type_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&_impl_.field_id_, &from._impl_.field_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.element_type_) -
    reinterpret_cast<char*>(&_impl_.field_id_)) + sizeof(_impl_.element_type_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.ColumnInfo)
}

inline void ColumnInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.nested_path_){arena}
    , decltype(_impl_.field_id_){int64_t{0}}
    , decltype(_impl_.data_type_){0}
    , decltype(_impl_.is_primary_key_){false}
    , decltype(_impl_.is_autoid_){false}
    , decltype(_impl_.is_partition_key_){false}
    , decltype(_impl_.element_type_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ColumnInfo::~ColumnInfo() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.ColumnInfo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ColumnInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.nested_path_.~RepeatedPtrField();
}

void ColumnInfo::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  _impl_.nested_path_.Clear();
  ::memset(&_impl_.field_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.element_type_) -
      reinterpret_cast<char*>(&_impl_.field_id_)) + sizeof(_impl_.element_type_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ColumnInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int64 field_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _impl_.field_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.schema.DataType data_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_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<uint8_t>(tag) == 24)) {
          _impl_.is_primary_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool is_autoID = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _impl_.is_autoid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated string nested_path = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_nested_path();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, "milvus.proto.plan.ColumnInfo.nested_path"));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else
          goto handle_unusual;
        continue;
      // bool is_partition_key = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _impl_.is_partition_key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.schema.DataType element_type = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_element_type(static_cast<::milvus::proto::schema::DataType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ColumnInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.ColumnInfo)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 field_id = 1;
  if (this->_internal_field_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_field_id(), target);
  }

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

  // bool is_primary_key = 3;
  if (this->_internal_is_primary_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_primary_key(), target);
  }

  // bool is_autoID = 4;
  if (this->_internal_is_autoid() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_is_autoid(), target);
  }

  // repeated string nested_path = 5;
  for (int i = 0, n = this->_internal_nested_path_size(); i < n; i++) {
    const auto& s = this->_internal_nested_path(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "milvus.proto.plan.ColumnInfo.nested_path");
    target = stream->WriteString(5, s, target);
  }

  // bool is_partition_key = 6;
  if (this->_internal_is_partition_key() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_is_partition_key(), target);
  }

  // .milvus.proto.schema.DataType element_type = 7;
  if (this->_internal_element_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      7, this->_internal_element_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string nested_path = 5;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.nested_path_.size());
  for (int i = 0, n = _impl_.nested_path_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      _impl_.nested_path_.Get(i));
  }

  // int64 field_id = 1;
  if (this->_internal_field_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_field_id());
  }

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

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

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

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

  // .milvus.proto.schema.DataType element_type = 7;
  if (this->_internal_element_type() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_element_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ColumnInfo::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    ColumnInfo::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ColumnInfo::GetClassData() const { return &_class_data_; }


void ColumnInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<ColumnInfo*>(&to_msg);
  auto& from = static_cast<const ColumnInfo&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.ColumnInfo)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.nested_path_.MergeFrom(from._impl_.nested_path_);
  if (from._internal_field_id() != 0) {
    _this->_internal_set_field_id(from._internal_field_id());
  }
  if (from._internal_data_type() != 0) {
    _this->_internal_set_data_type(from._internal_data_type());
  }
  if (from._internal_is_primary_key() != 0) {
    _this->_internal_set_is_primary_key(from._internal_is_primary_key());
  }
  if (from._internal_is_autoid() != 0) {
    _this->_internal_set_is_autoid(from._internal_is_autoid());
  }
  if (from._internal_is_partition_key() != 0) {
    _this->_internal_set_is_partition_key(from._internal_is_partition_key());
  }
  if (from._internal_element_type() != 0) {
    _this->_internal_set_element_type(from._internal_element_type());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  _impl_.nested_path_.InternalSwap(&other->_impl_.nested_path_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ColumnInfo, _impl_.element_type_)
      + sizeof(ColumnInfo::_impl_.element_type_)
      - PROTOBUF_FIELD_OFFSET(ColumnInfo, _impl_.field_id_)>(
          reinterpret_cast<char*>(&_impl_.field_id_),
          reinterpret_cast<char*>(&other->_impl_.field_id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ColumnInfo::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[3]);
}

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

class ColumnExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& info(const ColumnExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
ColumnExpr::_Internal::info(const ColumnExpr* msg) {
  return *msg->_impl_.info_;
}
ColumnExpr::ColumnExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.ColumnExpr)
}
ColumnExpr::ColumnExpr(const ColumnExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  ColumnExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.info_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_info()) {
    _this->_impl_.info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.info_);
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.ColumnExpr)
}

inline void ColumnExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.info_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ColumnExpr::~ColumnExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.ColumnExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ColumnExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.info_;
}

void ColumnExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.info_ != nullptr) {
    delete _impl_.info_;
  }
  _impl_.info_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ColumnExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ColumnExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.ColumnExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo info = 1;
  if (this->_internal_has_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::info(this),
        _Internal::info(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.ColumnExpr)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo info = 1;
  if (this->_internal_has_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.info_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ColumnExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    ColumnExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ColumnExpr::GetClassData() const { return &_class_data_; }


void ColumnExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<ColumnExpr*>(&to_msg);
  auto& from = static_cast<const ColumnExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.ColumnExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_info()) {
    _this->_internal_mutable_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_info());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ColumnExpr::InternalSwap(ColumnExpr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.info_, other->_impl_.info_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ColumnExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[4]);
}

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

class ExistsExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& info(const ExistsExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
ExistsExpr::_Internal::info(const ExistsExpr* msg) {
  return *msg->_impl_.info_;
}
ExistsExpr::ExistsExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.ExistsExpr)
}
ExistsExpr::ExistsExpr(const ExistsExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  ExistsExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.info_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_info()) {
    _this->_impl_.info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.info_);
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.ExistsExpr)
}

inline void ExistsExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.info_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ExistsExpr::~ExistsExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.ExistsExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ExistsExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.info_;
}

void ExistsExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.info_ != nullptr) {
    delete _impl_.info_;
  }
  _impl_.info_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ExistsExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ExistsExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.ExistsExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo info = 1;
  if (this->_internal_has_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::info(this),
        _Internal::info(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.ExistsExpr)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .milvus.proto.plan.ColumnInfo info = 1;
  if (this->_internal_has_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.info_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExistsExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    ExistsExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExistsExpr::GetClassData() const { return &_class_data_; }


void ExistsExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<ExistsExpr*>(&to_msg);
  auto& from = static_cast<const ExistsExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.ExistsExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_info()) {
    _this->_internal_mutable_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_info());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ExistsExpr::InternalSwap(ExistsExpr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.info_, other->_impl_.info_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ExistsExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[5]);
}

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

class ValueExpr::_Internal {
 public:
  static const ::milvus::proto::plan::GenericValue& value(const ValueExpr* msg);
};

const ::milvus::proto::plan::GenericValue&
ValueExpr::_Internal::value(const ValueExpr* msg) {
  return *msg->_impl_.value_;
}
ValueExpr::ValueExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.ValueExpr)
}
ValueExpr::ValueExpr(const ValueExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  ValueExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.value_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_value()) {
    _this->_impl_.value_ = new ::milvus::proto::plan::GenericValue(*from._impl_.value_);
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.ValueExpr)
}

inline void ValueExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.value_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ValueExpr::~ValueExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.ValueExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ValueExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.value_;
}

void ValueExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
    delete _impl_.value_;
  }
  _impl_.value_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ValueExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.GenericValue value = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ValueExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.ValueExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.GenericValue value = 1;
  if (this->_internal_has_value()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::value(this),
        _Internal::value(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.ValueExpr)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ValueExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    ValueExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ValueExpr::GetClassData() const { return &_class_data_; }


void ValueExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<ValueExpr*>(&to_msg);
  auto& from = static_cast<const ValueExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.ValueExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_value()) {
    _this->_internal_mutable_value()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_value());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ValueExpr::InternalSwap(ValueExpr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.value_, other->_impl_.value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ValueExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[6]);
}

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

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->_impl_.column_info_;
}
const ::milvus::proto::plan::GenericValue&
UnaryRangeExpr::_Internal::value(const UnaryRangeExpr* msg) {
  return *msg->_impl_.value_;
}
UnaryRangeExpr::UnaryRangeExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.UnaryRangeExpr)
}
UnaryRangeExpr::UnaryRangeExpr(const UnaryRangeExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  UnaryRangeExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.value_){nullptr}
    , decltype(_impl_.op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_column_info()) {
    _this->_impl_.column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.column_info_);
  }
  if (from._internal_has_value()) {
    _this->_impl_.value_ = new ::milvus::proto::plan::GenericValue(*from._impl_.value_);
  }
  _this->_impl_.op_ = from._impl_.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.UnaryRangeExpr)
}

inline void UnaryRangeExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.value_){nullptr}
    , decltype(_impl_.op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

UnaryRangeExpr::~UnaryRangeExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.UnaryRangeExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void UnaryRangeExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.column_info_;
  if (this != internal_default_instance()) delete _impl_.value_;
}

void UnaryRangeExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
    delete _impl_.value_;
  }
  _impl_.value_ = nullptr;
  _impl_.op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UnaryRangeExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_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<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UnaryRangeExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.UnaryRangeExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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->_internal_has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.column_info_);
  }

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

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UnaryRangeExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    UnaryRangeExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UnaryRangeExpr::GetClassData() const { return &_class_data_; }


void UnaryRangeExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<UnaryRangeExpr*>(&to_msg);
  auto& from = static_cast<const UnaryRangeExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.UnaryRangeExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_column_info()) {
    _this->_internal_mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_column_info());
  }
  if (from._internal_has_value()) {
    _this->_internal_mutable_value()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_value());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(UnaryRangeExpr, _impl_.op_)
      + sizeof(UnaryRangeExpr::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(UnaryRangeExpr, _impl_.column_info_)>(
          reinterpret_cast<char*>(&_impl_.column_info_),
          reinterpret_cast<char*>(&other->_impl_.column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata UnaryRangeExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[7]);
}

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

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->_impl_.column_info_;
}
const ::milvus::proto::plan::GenericValue&
BinaryRangeExpr::_Internal::lower_value(const BinaryRangeExpr* msg) {
  return *msg->_impl_.lower_value_;
}
const ::milvus::proto::plan::GenericValue&
BinaryRangeExpr::_Internal::upper_value(const BinaryRangeExpr* msg) {
  return *msg->_impl_.upper_value_;
}
BinaryRangeExpr::BinaryRangeExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.BinaryRangeExpr)
}
BinaryRangeExpr::BinaryRangeExpr(const BinaryRangeExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  BinaryRangeExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.lower_value_){nullptr}
    , decltype(_impl_.upper_value_){nullptr}
    , decltype(_impl_.lower_inclusive_){}
    , decltype(_impl_.upper_inclusive_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_column_info()) {
    _this->_impl_.column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.column_info_);
  }
  if (from._internal_has_lower_value()) {
    _this->_impl_.lower_value_ = new ::milvus::proto::plan::GenericValue(*from._impl_.lower_value_);
  }
  if (from._internal_has_upper_value()) {
    _this->_impl_.upper_value_ = new ::milvus::proto::plan::GenericValue(*from._impl_.upper_value_);
  }
  ::memcpy(&_impl_.lower_inclusive_, &from._impl_.lower_inclusive_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.upper_inclusive_) -
    reinterpret_cast<char*>(&_impl_.lower_inclusive_)) + sizeof(_impl_.upper_inclusive_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryRangeExpr)
}

inline void BinaryRangeExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.lower_value_){nullptr}
    , decltype(_impl_.upper_value_){nullptr}
    , decltype(_impl_.lower_inclusive_){false}
    , decltype(_impl_.upper_inclusive_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

BinaryRangeExpr::~BinaryRangeExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryRangeExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void BinaryRangeExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.column_info_;
  if (this != internal_default_instance()) delete _impl_.lower_value_;
  if (this != internal_default_instance()) delete _impl_.upper_value_;
}

void BinaryRangeExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

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

const char* BinaryRangeExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_column_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool lower_inclusive = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _impl_.lower_inclusive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool upper_inclusive = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _impl_.upper_inclusive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue lower_value = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_upper_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* BinaryRangeExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryRangeExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // bool lower_inclusive = 2;
  if (this->_internal_lower_inclusive() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_lower_inclusive(), target);
  }

  // bool upper_inclusive = 3;
  if (this->_internal_upper_inclusive() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_upper_inclusive(), target);
  }

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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->_internal_has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.column_info_);
  }

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

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

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

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BinaryRangeExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    BinaryRangeExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BinaryRangeExpr::GetClassData() const { return &_class_data_; }


void BinaryRangeExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<BinaryRangeExpr*>(&to_msg);
  auto& from = static_cast<const BinaryRangeExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryRangeExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_column_info()) {
    _this->_internal_mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_column_info());
  }
  if (from._internal_has_lower_value()) {
    _this->_internal_mutable_lower_value()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_lower_value());
  }
  if (from._internal_has_upper_value()) {
    _this->_internal_mutable_upper_value()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_upper_value());
  }
  if (from._internal_lower_inclusive() != 0) {
    _this->_internal_set_lower_inclusive(from._internal_lower_inclusive());
  }
  if (from._internal_upper_inclusive() != 0) {
    _this->_internal_set_upper_inclusive(from._internal_upper_inclusive());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BinaryRangeExpr, _impl_.upper_inclusive_)
      + sizeof(BinaryRangeExpr::_impl_.upper_inclusive_)
      - PROTOBUF_FIELD_OFFSET(BinaryRangeExpr, _impl_.column_info_)>(
          reinterpret_cast<char*>(&_impl_.column_info_),
          reinterpret_cast<char*>(&other->_impl_.column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryRangeExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[8]);
}

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

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->_impl_.left_column_info_;
}
const ::milvus::proto::plan::ColumnInfo&
CompareExpr::_Internal::right_column_info(const CompareExpr* msg) {
  return *msg->_impl_.right_column_info_;
}
CompareExpr::CompareExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.CompareExpr)
}
CompareExpr::CompareExpr(const CompareExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CompareExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.left_column_info_){nullptr}
    , decltype(_impl_.right_column_info_){nullptr}
    , decltype(_impl_.op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_left_column_info()) {
    _this->_impl_.left_column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.left_column_info_);
  }
  if (from._internal_has_right_column_info()) {
    _this->_impl_.right_column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.right_column_info_);
  }
  _this->_impl_.op_ = from._impl_.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.CompareExpr)
}

inline void CompareExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.left_column_info_){nullptr}
    , decltype(_impl_.right_column_info_){nullptr}
    , decltype(_impl_.op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

CompareExpr::~CompareExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.CompareExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CompareExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.left_column_info_;
  if (this != internal_default_instance()) delete _impl_.right_column_info_;
}

void CompareExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.left_column_info_ != nullptr) {
    delete _impl_.left_column_info_;
  }
  _impl_.left_column_info_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.right_column_info_ != nullptr) {
    delete _impl_.right_column_info_;
  }
  _impl_.right_column_info_ = nullptr;
  _impl_.op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CompareExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo left_column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_op(static_cast<::milvus::proto::plan::OpType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CompareExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.CompareExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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->_internal_has_left_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.left_column_info_);
  }

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

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompareExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CompareExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompareExpr::GetClassData() const { return &_class_data_; }


void CompareExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CompareExpr*>(&to_msg);
  auto& from = static_cast<const CompareExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.CompareExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_left_column_info()) {
    _this->_internal_mutable_left_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_left_column_info());
  }
  if (from._internal_has_right_column_info()) {
    _this->_internal_mutable_right_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_right_column_info());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CompareExpr, _impl_.op_)
      + sizeof(CompareExpr::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(CompareExpr, _impl_.left_column_info_)>(
          reinterpret_cast<char*>(&_impl_.left_column_info_),
          reinterpret_cast<char*>(&other->_impl_.left_column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CompareExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[9]);
}

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

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->_impl_.column_info_;
}
TermExpr::TermExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.TermExpr)
}
TermExpr::TermExpr(const TermExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  TermExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.values_){from._impl_.values_}
    , decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.is_in_field_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_column_info()) {
    _this->_impl_.column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.column_info_);
  }
  _this->_impl_.is_in_field_ = from._impl_.is_in_field_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.TermExpr)
}

inline void TermExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.values_){arena}
    , decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.is_in_field_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

TermExpr::~TermExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.TermExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void TermExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.values_.~RepeatedPtrField();
  if (this != internal_default_instance()) delete _impl_.column_info_;
}

void TermExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  _impl_.values_.Clear();
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
  _impl_.is_in_field_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TermExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // bool is_in_field = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _impl_.is_in_field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* TermExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.TermExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .milvus.proto.plan.GenericValue values = 2;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_values_size()); i < n; i++) {
    const auto& repfield = this->_internal_values(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
  }

  // bool is_in_field = 3;
  if (this->_internal_is_in_field() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_in_field(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .milvus.proto.plan.GenericValue values = 2;
  total_size += 1UL * this->_internal_values_size();
  for (const auto& msg : this->_impl_.values_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TermExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    TermExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TermExpr::GetClassData() const { return &_class_data_; }


void TermExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<TermExpr*>(&to_msg);
  auto& from = static_cast<const TermExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.TermExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.values_.MergeFrom(from._impl_.values_);
  if (from._internal_has_column_info()) {
    _this->_internal_mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_column_info());
  }
  if (from._internal_is_in_field() != 0) {
    _this->_internal_set_is_in_field(from._internal_is_in_field());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  _impl_.values_.InternalSwap(&other->_impl_.values_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TermExpr, _impl_.is_in_field_)
      + sizeof(TermExpr::_impl_.is_in_field_)
      - PROTOBUF_FIELD_OFFSET(TermExpr, _impl_.column_info_)>(
          reinterpret_cast<char*>(&_impl_.column_info_),
          reinterpret_cast<char*>(&other->_impl_.column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata TermExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[10]);
}

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

class JSONContainsExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& column_info(const JSONContainsExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
JSONContainsExpr::_Internal::column_info(const JSONContainsExpr* msg) {
  return *msg->_impl_.column_info_;
}
JSONContainsExpr::JSONContainsExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.JSONContainsExpr)
}
JSONContainsExpr::JSONContainsExpr(const JSONContainsExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  JSONContainsExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.elements_){from._impl_.elements_}
    , decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.op_){}
    , decltype(_impl_.elements_same_type_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_column_info()) {
    _this->_impl_.column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.column_info_);
  }
  ::memcpy(&_impl_.op_, &from._impl_.op_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.elements_same_type_) -
    reinterpret_cast<char*>(&_impl_.op_)) + sizeof(_impl_.elements_same_type_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.JSONContainsExpr)
}

inline void JSONContainsExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.elements_){arena}
    , decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.op_){0}
    , decltype(_impl_.elements_same_type_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

JSONContainsExpr::~JSONContainsExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.JSONContainsExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void JSONContainsExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.elements_.~RepeatedPtrField();
  if (this != internal_default_instance()) delete _impl_.column_info_;
}

void JSONContainsExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  _impl_.elements_.Clear();
  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
  ::memset(&_impl_.op_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.elements_same_type_) -
      reinterpret_cast<char*>(&_impl_.op_)) + sizeof(_impl_.elements_same_type_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* JSONContainsExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_column_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .milvus.proto.plan.GenericValue elements = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_elements(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.JSONContainsExpr.JSONOp op = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_op(static_cast<::milvus::proto::plan::JSONContainsExpr_JSONOp>(val));
        } else
          goto handle_unusual;
        continue;
      // bool elements_same_type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _impl_.elements_same_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* JSONContainsExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.JSONContainsExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .milvus.proto.plan.GenericValue elements = 2;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_elements_size()); i < n; i++) {
    const auto& repfield = this->_internal_elements(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.JSONContainsExpr.JSONOp op = 3;
  if (this->_internal_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      3, this->_internal_op(), target);
  }

  // bool elements_same_type = 4;
  if (this->_internal_elements_same_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_elements_same_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.JSONContainsExpr)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .milvus.proto.plan.GenericValue elements = 2;
  total_size += 1UL * this->_internal_elements_size();
  for (const auto& msg : this->_impl_.elements_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

  // .milvus.proto.plan.JSONContainsExpr.JSONOp op = 3;
  if (this->_internal_op() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_op());
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData JSONContainsExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    JSONContainsExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*JSONContainsExpr::GetClassData() const { return &_class_data_; }


void JSONContainsExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<JSONContainsExpr*>(&to_msg);
  auto& from = static_cast<const JSONContainsExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.JSONContainsExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.elements_.MergeFrom(from._impl_.elements_);
  if (from._internal_has_column_info()) {
    _this->_internal_mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_column_info());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  if (from._internal_elements_same_type() != 0) {
    _this->_internal_set_elements_same_type(from._internal_elements_same_type());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void JSONContainsExpr::InternalSwap(JSONContainsExpr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.elements_.InternalSwap(&other->_impl_.elements_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(JSONContainsExpr, _impl_.elements_same_type_)
      + sizeof(JSONContainsExpr::_impl_.elements_same_type_)
      - PROTOBUF_FIELD_OFFSET(JSONContainsExpr, _impl_.column_info_)>(
          reinterpret_cast<char*>(&_impl_.column_info_),
          reinterpret_cast<char*>(&other->_impl_.column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata JSONContainsExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[11]);
}

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

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->_impl_.child_;
}
UnaryExpr::UnaryExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.UnaryExpr)
}
UnaryExpr::UnaryExpr(const UnaryExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  UnaryExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.child_){nullptr}
    , decltype(_impl_.op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_child()) {
    _this->_impl_.child_ = new ::milvus::proto::plan::Expr(*from._impl_.child_);
  }
  _this->_impl_.op_ = from._impl_.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.UnaryExpr)
}

inline void UnaryExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.child_){nullptr}
    , decltype(_impl_.op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

UnaryExpr::~UnaryExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.UnaryExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void UnaryExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.child_;
}

void UnaryExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.child_ != nullptr) {
    delete _impl_.child_;
  }
  _impl_.child_ = nullptr;
  _impl_.op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UnaryExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.UnaryExpr.UnaryOp op = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_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<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UnaryExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.UnaryExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.child_);
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UnaryExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    UnaryExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UnaryExpr::GetClassData() const { return &_class_data_; }


void UnaryExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<UnaryExpr*>(&to_msg);
  auto& from = static_cast<const UnaryExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.UnaryExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_child()) {
    _this->_internal_mutable_child()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_child());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(UnaryExpr, _impl_.op_)
      + sizeof(UnaryExpr::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(UnaryExpr, _impl_.child_)>(
          reinterpret_cast<char*>(&_impl_.child_),
          reinterpret_cast<char*>(&other->_impl_.child_));
}

::PROTOBUF_NAMESPACE_ID::Metadata UnaryExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[12]);
}

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

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->_impl_.left_;
}
const ::milvus::proto::plan::Expr&
BinaryExpr::_Internal::right(const BinaryExpr* msg) {
  return *msg->_impl_.right_;
}
BinaryExpr::BinaryExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.BinaryExpr)
}
BinaryExpr::BinaryExpr(const BinaryExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  BinaryExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.left_){nullptr}
    , decltype(_impl_.right_){nullptr}
    , decltype(_impl_.op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_left()) {
    _this->_impl_.left_ = new ::milvus::proto::plan::Expr(*from._impl_.left_);
  }
  if (from._internal_has_right()) {
    _this->_impl_.right_ = new ::milvus::proto::plan::Expr(*from._impl_.right_);
  }
  _this->_impl_.op_ = from._impl_.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryExpr)
}

inline void BinaryExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.left_){nullptr}
    , decltype(_impl_.right_){nullptr}
    , decltype(_impl_.op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

BinaryExpr::~BinaryExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void BinaryExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.left_;
  if (this != internal_default_instance()) delete _impl_.right_;
}

void BinaryExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.left_ != nullptr) {
    delete _impl_.left_;
  }
  _impl_.left_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.right_ != nullptr) {
    delete _impl_.right_;
  }
  _impl_.right_ = nullptr;
  _impl_.op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* BinaryExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.BinaryExpr.BinaryOp op = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_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<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_left(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr right = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_right(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* BinaryExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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->_internal_has_left()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.left_);
  }

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

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BinaryExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    BinaryExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BinaryExpr::GetClassData() const { return &_class_data_; }


void BinaryExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<BinaryExpr*>(&to_msg);
  auto& from = static_cast<const BinaryExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_left()) {
    _this->_internal_mutable_left()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_left());
  }
  if (from._internal_has_right()) {
    _this->_internal_mutable_right()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_right());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BinaryExpr, _impl_.op_)
      + sizeof(BinaryExpr::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(BinaryExpr, _impl_.left_)>(
          reinterpret_cast<char*>(&_impl_.left_),
          reinterpret_cast<char*>(&other->_impl_.left_));
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[13]);
}

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

class BinaryArithOp::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& column_info(const BinaryArithOp* msg);
  static const ::milvus::proto::plan::GenericValue& right_operand(const BinaryArithOp* msg);
};

const ::milvus::proto::plan::ColumnInfo&
BinaryArithOp::_Internal::column_info(const BinaryArithOp* msg) {
  return *msg->_impl_.column_info_;
}
const ::milvus::proto::plan::GenericValue&
BinaryArithOp::_Internal::right_operand(const BinaryArithOp* msg) {
  return *msg->_impl_.right_operand_;
}
BinaryArithOp::BinaryArithOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.BinaryArithOp)
}
BinaryArithOp::BinaryArithOp(const BinaryArithOp& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  BinaryArithOp* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.right_operand_){nullptr}
    , decltype(_impl_.arith_op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_column_info()) {
    _this->_impl_.column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.column_info_);
  }
  if (from._internal_has_right_operand()) {
    _this->_impl_.right_operand_ = new ::milvus::proto::plan::GenericValue(*from._impl_.right_operand_);
  }
  _this->_impl_.arith_op_ = from._impl_.arith_op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryArithOp)
}

inline void BinaryArithOp::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.right_operand_){nullptr}
    , decltype(_impl_.arith_op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

BinaryArithOp::~BinaryArithOp() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryArithOp)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void BinaryArithOp::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.column_info_;
  if (this != internal_default_instance()) delete _impl_.right_operand_;
}

void BinaryArithOp::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.right_operand_ != nullptr) {
    delete _impl_.right_operand_;
  }
  _impl_.right_operand_ = nullptr;
  _impl_.arith_op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* BinaryArithOp::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_column_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.ArithOpType arith_op = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_arith_op(static_cast<::milvus::proto::plan::ArithOpType>(val));
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue right_operand = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_right_operand(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* BinaryArithOp::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryArithOp)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .milvus.proto.plan.ArithOpType arith_op = 2;
  if (this->_internal_arith_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      2, this->_internal_arith_op(), target);
  }

  // .milvus.proto.plan.GenericValue right_operand = 3;
  if (this->_internal_has_right_operand()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::right_operand(this),
        _Internal::right_operand(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryArithOp)
  return target;
}

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

  uint32_t 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->_internal_has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.column_info_);
  }

  // .milvus.proto.plan.GenericValue right_operand = 3;
  if (this->_internal_has_right_operand()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.right_operand_);
  }

  // .milvus.proto.plan.ArithOpType arith_op = 2;
  if (this->_internal_arith_op() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_arith_op());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BinaryArithOp::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    BinaryArithOp::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BinaryArithOp::GetClassData() const { return &_class_data_; }


void BinaryArithOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<BinaryArithOp*>(&to_msg);
  auto& from = static_cast<const BinaryArithOp&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryArithOp)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_column_info()) {
    _this->_internal_mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_column_info());
  }
  if (from._internal_has_right_operand()) {
    _this->_internal_mutable_right_operand()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_right_operand());
  }
  if (from._internal_arith_op() != 0) {
    _this->_internal_set_arith_op(from._internal_arith_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void BinaryArithOp::InternalSwap(BinaryArithOp* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BinaryArithOp, _impl_.arith_op_)
      + sizeof(BinaryArithOp::_impl_.arith_op_)
      - PROTOBUF_FIELD_OFFSET(BinaryArithOp, _impl_.column_info_)>(
          reinterpret_cast<char*>(&_impl_.column_info_),
          reinterpret_cast<char*>(&other->_impl_.column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryArithOp::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[14]);
}

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

class BinaryArithExpr::_Internal {
 public:
  static const ::milvus::proto::plan::Expr& left(const BinaryArithExpr* msg);
  static const ::milvus::proto::plan::Expr& right(const BinaryArithExpr* msg);
};

const ::milvus::proto::plan::Expr&
BinaryArithExpr::_Internal::left(const BinaryArithExpr* msg) {
  return *msg->_impl_.left_;
}
const ::milvus::proto::plan::Expr&
BinaryArithExpr::_Internal::right(const BinaryArithExpr* msg) {
  return *msg->_impl_.right_;
}
BinaryArithExpr::BinaryArithExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.BinaryArithExpr)
}
BinaryArithExpr::BinaryArithExpr(const BinaryArithExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  BinaryArithExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.left_){nullptr}
    , decltype(_impl_.right_){nullptr}
    , decltype(_impl_.op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_left()) {
    _this->_impl_.left_ = new ::milvus::proto::plan::Expr(*from._impl_.left_);
  }
  if (from._internal_has_right()) {
    _this->_impl_.right_ = new ::milvus::proto::plan::Expr(*from._impl_.right_);
  }
  _this->_impl_.op_ = from._impl_.op_;
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryArithExpr)
}

inline void BinaryArithExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.left_){nullptr}
    , decltype(_impl_.right_){nullptr}
    , decltype(_impl_.op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

BinaryArithExpr::~BinaryArithExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryArithExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void BinaryArithExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.left_;
  if (this != internal_default_instance()) delete _impl_.right_;
}

void BinaryArithExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.left_ != nullptr) {
    delete _impl_.left_;
  }
  _impl_.left_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.right_ != nullptr) {
    delete _impl_.right_;
  }
  _impl_.right_ = nullptr;
  _impl_.op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* BinaryArithExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.Expr left = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_left(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr right = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_right(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.ArithOpType op = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_op(static_cast<::milvus::proto::plan::ArithOpType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* BinaryArithExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryArithExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.Expr left = 1;
  if (this->_internal_has_left()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::left(this),
        _Internal::left(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.Expr right = 2;
  if (this->_internal_has_right()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::right(this),
        _Internal::right(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.ArithOpType op = 3;
  if (this->_internal_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      3, this->_internal_op(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryArithExpr)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BinaryArithExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    BinaryArithExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BinaryArithExpr::GetClassData() const { return &_class_data_; }


void BinaryArithExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<BinaryArithExpr*>(&to_msg);
  auto& from = static_cast<const BinaryArithExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryArithExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_left()) {
    _this->_internal_mutable_left()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_left());
  }
  if (from._internal_has_right()) {
    _this->_internal_mutable_right()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_right());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void BinaryArithExpr::InternalSwap(BinaryArithExpr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BinaryArithExpr, _impl_.op_)
      + sizeof(BinaryArithExpr::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(BinaryArithExpr, _impl_.left_)>(
          reinterpret_cast<char*>(&_impl_.left_),
          reinterpret_cast<char*>(&other->_impl_.left_));
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryArithExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[15]);
}

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

class BinaryArithOpEvalRangeExpr::_Internal {
 public:
  static const ::milvus::proto::plan::ColumnInfo& column_info(const BinaryArithOpEvalRangeExpr* msg);
  static const ::milvus::proto::plan::GenericValue& right_operand(const BinaryArithOpEvalRangeExpr* msg);
  static const ::milvus::proto::plan::GenericValue& value(const BinaryArithOpEvalRangeExpr* msg);
};

const ::milvus::proto::plan::ColumnInfo&
BinaryArithOpEvalRangeExpr::_Internal::column_info(const BinaryArithOpEvalRangeExpr* msg) {
  return *msg->_impl_.column_info_;
}
const ::milvus::proto::plan::GenericValue&
BinaryArithOpEvalRangeExpr::_Internal::right_operand(const BinaryArithOpEvalRangeExpr* msg) {
  return *msg->_impl_.right_operand_;
}
const ::milvus::proto::plan::GenericValue&
BinaryArithOpEvalRangeExpr::_Internal::value(const BinaryArithOpEvalRangeExpr* msg) {
  return *msg->_impl_.value_;
}
BinaryArithOpEvalRangeExpr::BinaryArithOpEvalRangeExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
}
BinaryArithOpEvalRangeExpr::BinaryArithOpEvalRangeExpr(const BinaryArithOpEvalRangeExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  BinaryArithOpEvalRangeExpr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.right_operand_){nullptr}
    , decltype(_impl_.value_){nullptr}
    , decltype(_impl_.arith_op_){}
    , decltype(_impl_.op_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_column_info()) {
    _this->_impl_.column_info_ = new ::milvus::proto::plan::ColumnInfo(*from._impl_.column_info_);
  }
  if (from._internal_has_right_operand()) {
    _this->_impl_.right_operand_ = new ::milvus::proto::plan::GenericValue(*from._impl_.right_operand_);
  }
  if (from._internal_has_value()) {
    _this->_impl_.value_ = new ::milvus::proto::plan::GenericValue(*from._impl_.value_);
  }
  ::memcpy(&_impl_.arith_op_, &from._impl_.arith_op_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.op_) -
    reinterpret_cast<char*>(&_impl_.arith_op_)) + sizeof(_impl_.op_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
}

inline void BinaryArithOpEvalRangeExpr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.column_info_){nullptr}
    , decltype(_impl_.right_operand_){nullptr}
    , decltype(_impl_.value_){nullptr}
    , decltype(_impl_.arith_op_){0}
    , decltype(_impl_.op_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

BinaryArithOpEvalRangeExpr::~BinaryArithOpEvalRangeExpr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void BinaryArithOpEvalRangeExpr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.column_info_;
  if (this != internal_default_instance()) delete _impl_.right_operand_;
  if (this != internal_default_instance()) delete _impl_.value_;
}

void BinaryArithOpEvalRangeExpr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.column_info_ != nullptr) {
    delete _impl_.column_info_;
  }
  _impl_.column_info_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.right_operand_ != nullptr) {
    delete _impl_.right_operand_;
  }
  _impl_.right_operand_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
    delete _impl_.value_;
  }
  _impl_.value_ = nullptr;
  ::memset(&_impl_.arith_op_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.op_) -
      reinterpret_cast<char*>(&_impl_.arith_op_)) + sizeof(_impl_.op_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* BinaryArithOpEvalRangeExpr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.ColumnInfo column_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_column_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.ArithOpType arith_op = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_arith_op(static_cast<::milvus::proto::plan::ArithOpType>(val));
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue right_operand = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_right_operand(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.OpType op = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_op(static_cast<::milvus::proto::plan::OpType>(val));
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.GenericValue value = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* BinaryArithOpEvalRangeExpr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .milvus.proto.plan.ArithOpType arith_op = 2;
  if (this->_internal_arith_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      2, this->_internal_arith_op(), target);
  }

  // .milvus.proto.plan.GenericValue right_operand = 3;
  if (this->_internal_has_right_operand()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::right_operand(this),
        _Internal::right_operand(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.OpType op = 4;
  if (this->_internal_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      4, this->_internal_op(), target);
  }

  // .milvus.proto.plan.GenericValue value = 5;
  if (this->_internal_has_value()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::value(this),
        _Internal::value(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
  return target;
}

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

  uint32_t 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->_internal_has_column_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.column_info_);
  }

  // .milvus.proto.plan.GenericValue right_operand = 3;
  if (this->_internal_has_right_operand()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.right_operand_);
  }

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

  // .milvus.proto.plan.ArithOpType arith_op = 2;
  if (this->_internal_arith_op() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_arith_op());
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BinaryArithOpEvalRangeExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    BinaryArithOpEvalRangeExpr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BinaryArithOpEvalRangeExpr::GetClassData() const { return &_class_data_; }


void BinaryArithOpEvalRangeExpr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<BinaryArithOpEvalRangeExpr*>(&to_msg);
  auto& from = static_cast<const BinaryArithOpEvalRangeExpr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_column_info()) {
    _this->_internal_mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(
        from._internal_column_info());
  }
  if (from._internal_has_right_operand()) {
    _this->_internal_mutable_right_operand()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_right_operand());
  }
  if (from._internal_has_value()) {
    _this->_internal_mutable_value()->::milvus::proto::plan::GenericValue::MergeFrom(
        from._internal_value());
  }
  if (from._internal_arith_op() != 0) {
    _this->_internal_set_arith_op(from._internal_arith_op());
  }
  if (from._internal_op() != 0) {
    _this->_internal_set_op(from._internal_op());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void BinaryArithOpEvalRangeExpr::InternalSwap(BinaryArithOpEvalRangeExpr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BinaryArithOpEvalRangeExpr, _impl_.op_)
      + sizeof(BinaryArithOpEvalRangeExpr::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(BinaryArithOpEvalRangeExpr, _impl_.column_info_)>(
          reinterpret_cast<char*>(&_impl_.column_info_),
          reinterpret_cast<char*>(&other->_impl_.column_info_));
}

::PROTOBUF_NAMESPACE_ID::Metadata BinaryArithOpEvalRangeExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[16]);
}

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

class AlwaysTrueExpr::_Internal {
 public:
};

AlwaysTrueExpr::AlwaysTrueExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.AlwaysTrueExpr)
}
AlwaysTrueExpr::AlwaysTrueExpr(const AlwaysTrueExpr& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  AlwaysTrueExpr* const _this = this; (void)_this;
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.AlwaysTrueExpr)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AlwaysTrueExpr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AlwaysTrueExpr::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata AlwaysTrueExpr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[17]);
}

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

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);
  static const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& binary_arith_op_eval_range_expr(const Expr* msg);
  static const ::milvus::proto::plan::BinaryArithExpr& binary_arith_expr(const Expr* msg);
  static const ::milvus::proto::plan::ValueExpr& value_expr(const Expr* msg);
  static const ::milvus::proto::plan::ColumnExpr& column_expr(const Expr* msg);
  static const ::milvus::proto::plan::ExistsExpr& exists_expr(const Expr* msg);
  static const ::milvus::proto::plan::AlwaysTrueExpr& always_true_expr(const Expr* msg);
  static const ::milvus::proto::plan::JSONContainsExpr& json_contains_expr(const Expr* msg);
};

const ::milvus::proto::plan::TermExpr&
Expr::_Internal::term_expr(const Expr* msg) {
  return *msg->_impl_.expr_.term_expr_;
}
const ::milvus::proto::plan::UnaryExpr&
Expr::_Internal::unary_expr(const Expr* msg) {
  return *msg->_impl_.expr_.unary_expr_;
}
const ::milvus::proto::plan::BinaryExpr&
Expr::_Internal::binary_expr(const Expr* msg) {
  return *msg->_impl_.expr_.binary_expr_;
}
const ::milvus::proto::plan::CompareExpr&
Expr::_Internal::compare_expr(const Expr* msg) {
  return *msg->_impl_.expr_.compare_expr_;
}
const ::milvus::proto::plan::UnaryRangeExpr&
Expr::_Internal::unary_range_expr(const Expr* msg) {
  return *msg->_impl_.expr_.unary_range_expr_;
}
const ::milvus::proto::plan::BinaryRangeExpr&
Expr::_Internal::binary_range_expr(const Expr* msg) {
  return *msg->_impl_.expr_.binary_range_expr_;
}
const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr&
Expr::_Internal::binary_arith_op_eval_range_expr(const Expr* msg) {
  return *msg->_impl_.expr_.binary_arith_op_eval_range_expr_;
}
const ::milvus::proto::plan::BinaryArithExpr&
Expr::_Internal::binary_arith_expr(const Expr* msg) {
  return *msg->_impl_.expr_.binary_arith_expr_;
}
const ::milvus::proto::plan::ValueExpr&
Expr::_Internal::value_expr(const Expr* msg) {
  return *msg->_impl_.expr_.value_expr_;
}
const ::milvus::proto::plan::ColumnExpr&
Expr::_Internal::column_expr(const Expr* msg) {
  return *msg->_impl_.expr_.column_expr_;
}
const ::milvus::proto::plan::ExistsExpr&
Expr::_Internal::exists_expr(const Expr* msg) {
  return *msg->_impl_.expr_.exists_expr_;
}
const ::milvus::proto::plan::AlwaysTrueExpr&
Expr::_Internal::always_true_expr(const Expr* msg) {
  return *msg->_impl_.expr_.always_true_expr_;
}
const ::milvus::proto::plan::JSONContainsExpr&
Expr::_Internal::json_contains_expr(const Expr* msg) {
  return *msg->_impl_.expr_.json_contains_expr_;
}
void Expr::set_allocated_term_expr(::milvus::proto::plan::TermExpr* term_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (term_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(term_expr);
    if (message_arena != submessage_arena) {
      term_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, term_expr, submessage_arena);
    }
    set_has_term_expr();
    _impl_.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 = GetArenaForAllocation();
  clear_expr();
  if (unary_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unary_expr);
    if (message_arena != submessage_arena) {
      unary_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unary_expr, submessage_arena);
    }
    set_has_unary_expr();
    _impl_.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 = GetArenaForAllocation();
  clear_expr();
  if (binary_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(binary_expr);
    if (message_arena != submessage_arena) {
      binary_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary_expr, submessage_arena);
    }
    set_has_binary_expr();
    _impl_.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 = GetArenaForAllocation();
  clear_expr();
  if (compare_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compare_expr);
    if (message_arena != submessage_arena) {
      compare_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, compare_expr, submessage_arena);
    }
    set_has_compare_expr();
    _impl_.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 = GetArenaForAllocation();
  clear_expr();
  if (unary_range_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unary_range_expr);
    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();
    _impl_.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 = GetArenaForAllocation();
  clear_expr();
  if (binary_range_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(binary_range_expr);
    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();
    _impl_.expr_.binary_range_expr_ = binary_range_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.binary_range_expr)
}
void Expr::set_allocated_binary_arith_op_eval_range_expr(::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (binary_arith_op_eval_range_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(binary_arith_op_eval_range_expr);
    if (message_arena != submessage_arena) {
      binary_arith_op_eval_range_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary_arith_op_eval_range_expr, submessage_arena);
    }
    set_has_binary_arith_op_eval_range_expr();
    _impl_.expr_.binary_arith_op_eval_range_expr_ = binary_arith_op_eval_range_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr)
}
void Expr::set_allocated_binary_arith_expr(::milvus::proto::plan::BinaryArithExpr* binary_arith_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (binary_arith_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(binary_arith_expr);
    if (message_arena != submessage_arena) {
      binary_arith_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary_arith_expr, submessage_arena);
    }
    set_has_binary_arith_expr();
    _impl_.expr_.binary_arith_expr_ = binary_arith_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.binary_arith_expr)
}
void Expr::set_allocated_value_expr(::milvus::proto::plan::ValueExpr* value_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (value_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value_expr);
    if (message_arena != submessage_arena) {
      value_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value_expr, submessage_arena);
    }
    set_has_value_expr();
    _impl_.expr_.value_expr_ = value_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.value_expr)
}
void Expr::set_allocated_column_expr(::milvus::proto::plan::ColumnExpr* column_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (column_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(column_expr);
    if (message_arena != submessage_arena) {
      column_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, column_expr, submessage_arena);
    }
    set_has_column_expr();
    _impl_.expr_.column_expr_ = column_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.column_expr)
}
void Expr::set_allocated_exists_expr(::milvus::proto::plan::ExistsExpr* exists_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (exists_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exists_expr);
    if (message_arena != submessage_arena) {
      exists_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, exists_expr, submessage_arena);
    }
    set_has_exists_expr();
    _impl_.expr_.exists_expr_ = exists_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.exists_expr)
}
void Expr::set_allocated_always_true_expr(::milvus::proto::plan::AlwaysTrueExpr* always_true_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (always_true_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(always_true_expr);
    if (message_arena != submessage_arena) {
      always_true_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, always_true_expr, submessage_arena);
    }
    set_has_always_true_expr();
    _impl_.expr_.always_true_expr_ = always_true_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.always_true_expr)
}
void Expr::set_allocated_json_contains_expr(::milvus::proto::plan::JSONContainsExpr* json_contains_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_expr();
  if (json_contains_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(json_contains_expr);
    if (message_arena != submessage_arena) {
      json_contains_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, json_contains_expr, submessage_arena);
    }
    set_has_json_contains_expr();
    _impl_.expr_.json_contains_expr_ = json_contains_expr;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.Expr.json_contains_expr)
}
Expr::Expr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.Expr)
}
Expr::Expr(const Expr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  Expr* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.expr_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_expr();
  switch (from.expr_case()) {
    case kTermExpr: {
      _this->_internal_mutable_term_expr()->::milvus::proto::plan::TermExpr::MergeFrom(
          from._internal_term_expr());
      break;
    }
    case kUnaryExpr: {
      _this->_internal_mutable_unary_expr()->::milvus::proto::plan::UnaryExpr::MergeFrom(
          from._internal_unary_expr());
      break;
    }
    case kBinaryExpr: {
      _this->_internal_mutable_binary_expr()->::milvus::proto::plan::BinaryExpr::MergeFrom(
          from._internal_binary_expr());
      break;
    }
    case kCompareExpr: {
      _this->_internal_mutable_compare_expr()->::milvus::proto::plan::CompareExpr::MergeFrom(
          from._internal_compare_expr());
      break;
    }
    case kUnaryRangeExpr: {
      _this->_internal_mutable_unary_range_expr()->::milvus::proto::plan::UnaryRangeExpr::MergeFrom(
          from._internal_unary_range_expr());
      break;
    }
    case kBinaryRangeExpr: {
      _this->_internal_mutable_binary_range_expr()->::milvus::proto::plan::BinaryRangeExpr::MergeFrom(
          from._internal_binary_range_expr());
      break;
    }
    case kBinaryArithOpEvalRangeExpr: {
      _this->_internal_mutable_binary_arith_op_eval_range_expr()->::milvus::proto::plan::BinaryArithOpEvalRangeExpr::MergeFrom(
          from._internal_binary_arith_op_eval_range_expr());
      break;
    }
    case kBinaryArithExpr: {
      _this->_internal_mutable_binary_arith_expr()->::milvus::proto::plan::BinaryArithExpr::MergeFrom(
          from._internal_binary_arith_expr());
      break;
    }
    case kValueExpr: {
      _this->_internal_mutable_value_expr()->::milvus::proto::plan::ValueExpr::MergeFrom(
          from._internal_value_expr());
      break;
    }
    case kColumnExpr: {
      _this->_internal_mutable_column_expr()->::milvus::proto::plan::ColumnExpr::MergeFrom(
          from._internal_column_expr());
      break;
    }
    case kExistsExpr: {
      _this->_internal_mutable_exists_expr()->::milvus::proto::plan::ExistsExpr::MergeFrom(
          from._internal_exists_expr());
      break;
    }
    case kAlwaysTrueExpr: {
      _this->_internal_mutable_always_true_expr()->::milvus::proto::plan::AlwaysTrueExpr::MergeFrom(
          from._internal_always_true_expr());
      break;
    }
    case kJsonContainsExpr: {
      _this->_internal_mutable_json_contains_expr()->::milvus::proto::plan::JSONContainsExpr::MergeFrom(
          from._internal_json_contains_expr());
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.Expr)
}

inline void Expr::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.expr_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_expr();
}

Expr::~Expr() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.Expr)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Expr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_expr()) {
    clear_expr();
  }
}

void Expr::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void Expr::clear_expr() {
// @@protoc_insertion_point(one_of_clear_start:milvus.proto.plan.Expr)
  switch (expr_case()) {
    case kTermExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.term_expr_;
      }
      break;
    }
    case kUnaryExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.unary_expr_;
      }
      break;
    }
    case kBinaryExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.binary_expr_;
      }
      break;
    }
    case kCompareExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.compare_expr_;
      }
      break;
    }
    case kUnaryRangeExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.unary_range_expr_;
      }
      break;
    }
    case kBinaryRangeExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.binary_range_expr_;
      }
      break;
    }
    case kBinaryArithOpEvalRangeExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.binary_arith_op_eval_range_expr_;
      }
      break;
    }
    case kBinaryArithExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.binary_arith_expr_;
      }
      break;
    }
    case kValueExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.value_expr_;
      }
      break;
    }
    case kColumnExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.column_expr_;
      }
      break;
    }
    case kExistsExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.exists_expr_;
      }
      break;
    }
    case kAlwaysTrueExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.always_true_expr_;
      }
      break;
    }
    case kJsonContainsExpr: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.expr_.json_contains_expr_;
      }
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = EXPR_NOT_SET;
}


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

  clear_expr();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.TermExpr term_expr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_binary_range_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_binary_arith_op_eval_range_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.BinaryArithExpr binary_arith_expr = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_binary_arith_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.ValueExpr value_expr = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_value_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.ColumnExpr column_expr = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_column_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.ExistsExpr exists_expr = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_exists_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.AlwaysTrueExpr always_true_expr = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_always_true_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.JSONContainsExpr json_contains_expr = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_json_contains_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* Expr::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.Expr)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.TermExpr term_expr = 1;
  if (_internal_has_term_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::term_expr(this),
        _Internal::term_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.UnaryExpr unary_expr = 2;
  if (_internal_has_unary_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::unary_expr(this),
        _Internal::unary_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.BinaryExpr binary_expr = 3;
  if (_internal_has_binary_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::binary_expr(this),
        _Internal::binary_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.CompareExpr compare_expr = 4;
  if (_internal_has_compare_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::compare_expr(this),
        _Internal::compare_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
  if (_internal_has_unary_range_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::unary_range_expr(this),
        _Internal::unary_range_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
  if (_internal_has_binary_range_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::binary_range_expr(this),
        _Internal::binary_range_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7;
  if (_internal_has_binary_arith_op_eval_range_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, _Internal::binary_arith_op_eval_range_expr(this),
        _Internal::binary_arith_op_eval_range_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.BinaryArithExpr binary_arith_expr = 8;
  if (_internal_has_binary_arith_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, _Internal::binary_arith_expr(this),
        _Internal::binary_arith_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.ValueExpr value_expr = 9;
  if (_internal_has_value_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(9, _Internal::value_expr(this),
        _Internal::value_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.ColumnExpr column_expr = 10;
  if (_internal_has_column_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(10, _Internal::column_expr(this),
        _Internal::column_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.ExistsExpr exists_expr = 11;
  if (_internal_has_exists_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(11, _Internal::exists_expr(this),
        _Internal::exists_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.AlwaysTrueExpr always_true_expr = 12;
  if (_internal_has_always_true_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(12, _Internal::always_true_expr(this),
        _Internal::always_true_expr(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.JSONContainsExpr json_contains_expr = 13;
  if (_internal_has_json_contains_expr()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(13, _Internal::json_contains_expr(this),
        _Internal::json_contains_expr(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t 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(
          *_impl_.expr_.term_expr_);
      break;
    }
    // .milvus.proto.plan.UnaryExpr unary_expr = 2;
    case kUnaryExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.unary_expr_);
      break;
    }
    // .milvus.proto.plan.BinaryExpr binary_expr = 3;
    case kBinaryExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.binary_expr_);
      break;
    }
    // .milvus.proto.plan.CompareExpr compare_expr = 4;
    case kCompareExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.compare_expr_);
      break;
    }
    // .milvus.proto.plan.UnaryRangeExpr unary_range_expr = 5;
    case kUnaryRangeExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.unary_range_expr_);
      break;
    }
    // .milvus.proto.plan.BinaryRangeExpr binary_range_expr = 6;
    case kBinaryRangeExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.binary_range_expr_);
      break;
    }
    // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7;
    case kBinaryArithOpEvalRangeExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.binary_arith_op_eval_range_expr_);
      break;
    }
    // .milvus.proto.plan.BinaryArithExpr binary_arith_expr = 8;
    case kBinaryArithExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.binary_arith_expr_);
      break;
    }
    // .milvus.proto.plan.ValueExpr value_expr = 9;
    case kValueExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.value_expr_);
      break;
    }
    // .milvus.proto.plan.ColumnExpr column_expr = 10;
    case kColumnExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.column_expr_);
      break;
    }
    // .milvus.proto.plan.ExistsExpr exists_expr = 11;
    case kExistsExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.exists_expr_);
      break;
    }
    // .milvus.proto.plan.AlwaysTrueExpr always_true_expr = 12;
    case kAlwaysTrueExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.always_true_expr_);
      break;
    }
    // .milvus.proto.plan.JSONContainsExpr json_contains_expr = 13;
    case kJsonContainsExpr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expr_.json_contains_expr_);
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    Expr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expr::GetClassData() const { return &_class_data_; }


void Expr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<Expr*>(&to_msg);
  auto& from = static_cast<const Expr&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.Expr)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.expr_case()) {
    case kTermExpr: {
      _this->_internal_mutable_term_expr()->::milvus::proto::plan::TermExpr::MergeFrom(
          from._internal_term_expr());
      break;
    }
    case kUnaryExpr: {
      _this->_internal_mutable_unary_expr()->::milvus::proto::plan::UnaryExpr::MergeFrom(
          from._internal_unary_expr());
      break;
    }
    case kBinaryExpr: {
      _this->_internal_mutable_binary_expr()->::milvus::proto::plan::BinaryExpr::MergeFrom(
          from._internal_binary_expr());
      break;
    }
    case kCompareExpr: {
      _this->_internal_mutable_compare_expr()->::milvus::proto::plan::CompareExpr::MergeFrom(
          from._internal_compare_expr());
      break;
    }
    case kUnaryRangeExpr: {
      _this->_internal_mutable_unary_range_expr()->::milvus::proto::plan::UnaryRangeExpr::MergeFrom(
          from._internal_unary_range_expr());
      break;
    }
    case kBinaryRangeExpr: {
      _this->_internal_mutable_binary_range_expr()->::milvus::proto::plan::BinaryRangeExpr::MergeFrom(
          from._internal_binary_range_expr());
      break;
    }
    case kBinaryArithOpEvalRangeExpr: {
      _this->_internal_mutable_binary_arith_op_eval_range_expr()->::milvus::proto::plan::BinaryArithOpEvalRangeExpr::MergeFrom(
          from._internal_binary_arith_op_eval_range_expr());
      break;
    }
    case kBinaryArithExpr: {
      _this->_internal_mutable_binary_arith_expr()->::milvus::proto::plan::BinaryArithExpr::MergeFrom(
          from._internal_binary_arith_expr());
      break;
    }
    case kValueExpr: {
      _this->_internal_mutable_value_expr()->::milvus::proto::plan::ValueExpr::MergeFrom(
          from._internal_value_expr());
      break;
    }
    case kColumnExpr: {
      _this->_internal_mutable_column_expr()->::milvus::proto::plan::ColumnExpr::MergeFrom(
          from._internal_column_expr());
      break;
    }
    case kExistsExpr: {
      _this->_internal_mutable_exists_expr()->::milvus::proto::plan::ExistsExpr::MergeFrom(
          from._internal_exists_expr());
      break;
    }
    case kAlwaysTrueExpr: {
      _this->_internal_mutable_always_true_expr()->::milvus::proto::plan::AlwaysTrueExpr::MergeFrom(
          from._internal_always_true_expr());
      break;
    }
    case kJsonContainsExpr: {
      _this->_internal_mutable_json_contains_expr()->::milvus::proto::plan::JSONContainsExpr::MergeFrom(
          from._internal_json_contains_expr());
      break;
    }
    case EXPR_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.expr_, other->_impl_.expr_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expr::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[18]);
}

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

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->_impl_.predicates_;
}
const ::milvus::proto::plan::QueryInfo&
VectorANNS::_Internal::query_info(const VectorANNS* msg) {
  return *msg->_impl_.query_info_;
}
VectorANNS::VectorANNS(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.VectorANNS)
}
VectorANNS::VectorANNS(const VectorANNS& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  VectorANNS* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.placeholder_tag_){}
    , decltype(_impl_.predicates_){nullptr}
    , decltype(_impl_.query_info_){nullptr}
    , decltype(_impl_.field_id_){}
    , decltype(_impl_.vector_type_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.placeholder_tag_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.placeholder_tag_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_placeholder_tag().empty()) {
    _this->_impl_.placeholder_tag_.Set(from._internal_placeholder_tag(), 
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_predicates()) {
    _this->_impl_.predicates_ = new ::milvus::proto::plan::Expr(*from._impl_.predicates_);
  }
  if (from._internal_has_query_info()) {
    _this->_impl_.query_info_ = new ::milvus::proto::plan::QueryInfo(*from._impl_.query_info_);
  }
  ::memcpy(&_impl_.field_id_, &from._impl_.field_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.vector_type_) -
    reinterpret_cast<char*>(&_impl_.field_id_)) + sizeof(_impl_.vector_type_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.VectorANNS)
}

inline void VectorANNS::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.placeholder_tag_){}
    , decltype(_impl_.predicates_){nullptr}
    , decltype(_impl_.query_info_){nullptr}
    , decltype(_impl_.field_id_){int64_t{0}}
    , decltype(_impl_.vector_type_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.placeholder_tag_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.placeholder_tag_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

VectorANNS::~VectorANNS() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.VectorANNS)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void VectorANNS::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.placeholder_tag_.Destroy();
  if (this != internal_default_instance()) delete _impl_.predicates_;
  if (this != internal_default_instance()) delete _impl_.query_info_;
}

void VectorANNS::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  _impl_.placeholder_tag_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.predicates_ != nullptr) {
    delete _impl_.predicates_;
  }
  _impl_.predicates_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.query_info_ != nullptr) {
    delete _impl_.query_info_;
  }
  _impl_.query_info_ = nullptr;
  ::memset(&_impl_.field_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.vector_type_) -
      reinterpret_cast<char*>(&_impl_.field_id_)) + sizeof(_impl_.vector_type_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* VectorANNS::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.VectorType vector_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_vector_type(static_cast<::milvus::proto::plan::VectorType>(val));
        } else
          goto handle_unusual;
        continue;
      // int64 field_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _impl_.field_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr predicates = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_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<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_query_info(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string placeholder_tag = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          auto str = _internal_mutable_placeholder_tag();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, "milvus.proto.plan.VectorANNS.placeholder_tag"));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* VectorANNS::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.VectorANNS)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.VectorType vector_type = 1;
  if (this->_internal_vector_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      1, this->_internal_vector_type(), target);
  }

  // int64 field_id = 2;
  if (this->_internal_field_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_field_id(), target);
  }

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

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

  // int64 field_id = 2;
  if (this->_internal_field_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_field_id());
  }

  // .milvus.proto.plan.VectorType vector_type = 1;
  if (this->_internal_vector_type() != 0) {
    total_size += 1 +
      ::_pbi::WireFormatLite::EnumSize(this->_internal_vector_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VectorANNS::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    VectorANNS::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VectorANNS::GetClassData() const { return &_class_data_; }


void VectorANNS::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<VectorANNS*>(&to_msg);
  auto& from = static_cast<const VectorANNS&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.VectorANNS)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_placeholder_tag().empty()) {
    _this->_internal_set_placeholder_tag(from._internal_placeholder_tag());
  }
  if (from._internal_has_predicates()) {
    _this->_internal_mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_predicates());
  }
  if (from._internal_has_query_info()) {
    _this->_internal_mutable_query_info()->::milvus::proto::plan::QueryInfo::MergeFrom(
        from._internal_query_info());
  }
  if (from._internal_field_id() != 0) {
    _this->_internal_set_field_id(from._internal_field_id());
  }
  if (from._internal_vector_type() != 0) {
    _this->_internal_set_vector_type(from._internal_vector_type());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.placeholder_tag_, lhs_arena,
      &other->_impl_.placeholder_tag_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(VectorANNS, _impl_.vector_type_)
      + sizeof(VectorANNS::_impl_.vector_type_)
      - PROTOBUF_FIELD_OFFSET(VectorANNS, _impl_.predicates_)>(
          reinterpret_cast<char*>(&_impl_.predicates_),
          reinterpret_cast<char*>(&other->_impl_.predicates_));
}

::PROTOBUF_NAMESPACE_ID::Metadata VectorANNS::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[19]);
}

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

class QueryPlanNode::_Internal {
 public:
  static const ::milvus::proto::plan::Expr& predicates(const QueryPlanNode* msg);
};

const ::milvus::proto::plan::Expr&
QueryPlanNode::_Internal::predicates(const QueryPlanNode* msg) {
  return *msg->_impl_.predicates_;
}
QueryPlanNode::QueryPlanNode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.QueryPlanNode)
}
QueryPlanNode::QueryPlanNode(const QueryPlanNode& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  QueryPlanNode* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.predicates_){nullptr}
    , decltype(_impl_.limit_){}
    , decltype(_impl_.is_count_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_predicates()) {
    _this->_impl_.predicates_ = new ::milvus::proto::plan::Expr(*from._impl_.predicates_);
  }
  ::memcpy(&_impl_.limit_, &from._impl_.limit_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_count_) -
    reinterpret_cast<char*>(&_impl_.limit_)) + sizeof(_impl_.is_count_));
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.QueryPlanNode)
}

inline void QueryPlanNode::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.predicates_){nullptr}
    , decltype(_impl_.limit_){int64_t{0}}
    , decltype(_impl_.is_count_){false}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

QueryPlanNode::~QueryPlanNode() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.QueryPlanNode)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void QueryPlanNode::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.predicates_;
}

void QueryPlanNode::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

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

  if (GetArenaForAllocation() == nullptr && _impl_.predicates_ != nullptr) {
    delete _impl_.predicates_;
  }
  _impl_.predicates_ = nullptr;
  ::memset(&_impl_.limit_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.is_count_) -
      reinterpret_cast<char*>(&_impl_.limit_)) + sizeof(_impl_.is_count_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* QueryPlanNode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.Expr predicates = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_predicates(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool is_count = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _impl_.is_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 limit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _impl_.limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* QueryPlanNode::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.QueryPlanNode)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.Expr predicates = 1;
  if (this->_internal_has_predicates()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::predicates(this),
        _Internal::predicates(this).GetCachedSize(), target, stream);
  }

  // bool is_count = 2;
  if (this->_internal_is_count() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_is_count(), target);
  }

  // int64 limit = 3;
  if (this->_internal_limit() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_limit(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.QueryPlanNode)
  return target;
}

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

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

  // int64 limit = 3;
  if (this->_internal_limit() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_limit());
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData QueryPlanNode::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    QueryPlanNode::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*QueryPlanNode::GetClassData() const { return &_class_data_; }


void QueryPlanNode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<QueryPlanNode*>(&to_msg);
  auto& from = static_cast<const QueryPlanNode&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.QueryPlanNode)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_predicates()) {
    _this->_internal_mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(
        from._internal_predicates());
  }
  if (from._internal_limit() != 0) {
    _this->_internal_set_limit(from._internal_limit());
  }
  if (from._internal_is_count() != 0) {
    _this->_internal_set_is_count(from._internal_is_count());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void QueryPlanNode::InternalSwap(QueryPlanNode* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(QueryPlanNode, _impl_.is_count_)
      + sizeof(QueryPlanNode::_impl_.is_count_)
      - PROTOBUF_FIELD_OFFSET(QueryPlanNode, _impl_.predicates_)>(
          reinterpret_cast<char*>(&_impl_.predicates_),
          reinterpret_cast<char*>(&other->_impl_.predicates_));
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryPlanNode::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[20]);
}

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

class PlanNode::_Internal {
 public:
  static const ::milvus::proto::plan::VectorANNS& vector_anns(const PlanNode* msg);
  static const ::milvus::proto::plan::Expr& predicates(const PlanNode* msg);
  static const ::milvus::proto::plan::QueryPlanNode& query(const PlanNode* msg);
};

const ::milvus::proto::plan::VectorANNS&
PlanNode::_Internal::vector_anns(const PlanNode* msg) {
  return *msg->_impl_.node_.vector_anns_;
}
const ::milvus::proto::plan::Expr&
PlanNode::_Internal::predicates(const PlanNode* msg) {
  return *msg->_impl_.node_.predicates_;
}
const ::milvus::proto::plan::QueryPlanNode&
PlanNode::_Internal::query(const PlanNode* msg) {
  return *msg->_impl_.node_.query_;
}
void PlanNode::set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_node();
  if (vector_anns) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vector_anns);
    if (message_arena != submessage_arena) {
      vector_anns = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vector_anns, submessage_arena);
    }
    set_has_vector_anns();
    _impl_.node_.vector_anns_ = vector_anns;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.vector_anns)
}
void PlanNode::set_allocated_predicates(::milvus::proto::plan::Expr* predicates) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_node();
  if (predicates) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(predicates);
    if (message_arena != submessage_arena) {
      predicates = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, predicates, submessage_arena);
    }
    set_has_predicates();
    _impl_.node_.predicates_ = predicates;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.predicates)
}
void PlanNode::set_allocated_query(::milvus::proto::plan::QueryPlanNode* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_node();
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    set_has_query();
    _impl_.node_.query_ = query;
  }
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.query)
}
PlanNode::PlanNode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:milvus.proto.plan.PlanNode)
}
PlanNode::PlanNode(const PlanNode& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  PlanNode* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.output_field_ids_){from._impl_.output_field_ids_}
    , /*decltype(_impl_._output_field_ids_cached_byte_size_)*/{0}
    , decltype(_impl_.node_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_node();
  switch (from.node_case()) {
    case kVectorAnns: {
      _this->_internal_mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(
          from._internal_vector_anns());
      break;
    }
    case kPredicates: {
      _this->_internal_mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(
          from._internal_predicates());
      break;
    }
    case kQuery: {
      _this->_internal_mutable_query()->::milvus::proto::plan::QueryPlanNode::MergeFrom(
          from._internal_query());
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.PlanNode)
}

inline void PlanNode::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.output_field_ids_){arena}
    , /*decltype(_impl_._output_field_ids_cached_byte_size_)*/{0}
    , decltype(_impl_.node_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_node();
}

PlanNode::~PlanNode() {
  // @@protoc_insertion_point(destructor:milvus.proto.plan.PlanNode)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PlanNode::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.output_field_ids_.~RepeatedField();
  if (has_node()) {
    clear_node();
  }
}

void PlanNode::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PlanNode::clear_node() {
// @@protoc_insertion_point(one_of_clear_start:milvus.proto.plan.PlanNode)
  switch (node_case()) {
    case kVectorAnns: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.node_.vector_anns_;
      }
      break;
    }
    case kPredicates: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.node_.predicates_;
      }
      break;
    }
    case kQuery: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.node_.query_;
      }
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = NODE_NOT_SET;
}


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

  _impl_.output_field_ids_.Clear();
  clear_node();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* PlanNode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .milvus.proto.plan.VectorANNS vector_anns = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_vector_anns(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.Expr predicates = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_predicates(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated int64 output_field_ids = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_output_field_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<uint8_t>(tag) == 24) {
          _internal_add_output_field_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .milvus.proto.plan.QueryPlanNode query = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_query(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* PlanNode::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.PlanNode)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .milvus.proto.plan.VectorANNS vector_anns = 1;
  if (_internal_has_vector_anns()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::vector_anns(this),
        _Internal::vector_anns(this).GetCachedSize(), target, stream);
  }

  // .milvus.proto.plan.Expr predicates = 2;
  if (_internal_has_predicates()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::predicates(this),
        _Internal::predicates(this).GetCachedSize(), target, stream);
  }

  // repeated int64 output_field_ids = 3;
  {
    int byte_size = _impl_._output_field_ids_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt64Packed(
          3, _internal_output_field_ids(), byte_size, target);
    }
  }

  // .milvus.proto.plan.QueryPlanNode query = 4;
  if (_internal_has_query()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::query(this),
        _Internal::query(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@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;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int64 output_field_ids = 3;
  {
    size_t data_size = ::_pbi::WireFormatLite::
      Int64Size(this->_impl_.output_field_ids_);
    if (data_size > 0) {
      total_size += 1 +
        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
    }
    int cached_size = ::_pbi::ToCachedSize(data_size);
    _impl_._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(
          *_impl_.node_.vector_anns_);
      break;
    }
    // .milvus.proto.plan.Expr predicates = 2;
    case kPredicates: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.node_.predicates_);
      break;
    }
    // .milvus.proto.plan.QueryPlanNode query = 4;
    case kQuery: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.node_.query_);
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PlanNode::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    PlanNode::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PlanNode::GetClassData() const { return &_class_data_; }


void PlanNode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<PlanNode*>(&to_msg);
  auto& from = static_cast<const PlanNode&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.PlanNode)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.output_field_ids_.MergeFrom(from._impl_.output_field_ids_);
  switch (from.node_case()) {
    case kVectorAnns: {
      _this->_internal_mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(
          from._internal_vector_anns());
      break;
    }
    case kPredicates: {
      _this->_internal_mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(
          from._internal_predicates());
      break;
    }
    case kQuery: {
      _this->_internal_mutable_query()->::milvus::proto::plan::QueryPlanNode::MergeFrom(
          from._internal_query());
      break;
    }
    case NODE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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_.InternalSwap(&other->_internal_metadata_);
  _impl_.output_field_ids_.InternalSwap(&other->_impl_.output_field_ids_);
  swap(_impl_.node_, other->_impl_.node_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata PlanNode::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once,
      file_level_metadata_plan_2eproto[21]);
}

// @@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::CreateMessageInternal< ::milvus::proto::plan::GenericValue >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::Array*
Arena::CreateMaybeMessage< ::milvus::proto::plan::Array >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::Array >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::QueryInfo*
Arena::CreateMaybeMessage< ::milvus::proto::plan::QueryInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::QueryInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::ColumnInfo*
Arena::CreateMaybeMessage< ::milvus::proto::plan::ColumnInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::ColumnInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::ColumnExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::ColumnExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::ColumnExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::ExistsExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::ExistsExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::ExistsExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::ValueExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::ValueExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::ValueExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::UnaryRangeExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::UnaryRangeExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::UnaryRangeExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryRangeExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryRangeExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::BinaryRangeExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::CompareExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::CompareExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::CompareExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::TermExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::TermExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::TermExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::JSONContainsExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::JSONContainsExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::JSONContainsExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::UnaryExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::UnaryExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::UnaryExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::BinaryExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryArithOp*
Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryArithOp >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::BinaryArithOp >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryArithExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryArithExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::BinaryArithExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryArithOpEvalRangeExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::AlwaysTrueExpr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::AlwaysTrueExpr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::AlwaysTrueExpr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::Expr*
Arena::CreateMaybeMessage< ::milvus::proto::plan::Expr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::Expr >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::VectorANNS*
Arena::CreateMaybeMessage< ::milvus::proto::plan::VectorANNS >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::VectorANNS >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::QueryPlanNode*
Arena::CreateMaybeMessage< ::milvus::proto::plan::QueryPlanNode >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::QueryPlanNode >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::plan::PlanNode*
Arena::CreateMaybeMessage< ::milvus::proto::plan::PlanNode >(Arena* arena) {
  return Arena::CreateMessageInternal< ::milvus::proto::plan::PlanNode >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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