diff --git a/internal/core/src/pb/plan.pb.cc b/internal/core/src/pb/plan.pb.cc index edc1ef9ee7..f8145a8e46 100644 --- a/internal/core/src/pb/plan.pb.cc +++ b/internal/core/src/pb/plan.pb.cc @@ -15,7 +15,8 @@ #include // @@protoc_insertion_point(includes) #include -extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_BinaryExpr_plan_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_BinaryArithOpEvalRangeExpr_plan_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_BinaryExpr_plan_2eproto; extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_BinaryRangeExpr_plan_2eproto; extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ColumnInfo_plan_2eproto; extern PROTOBUF_INTERNAL_EXPORT_plan_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CompareExpr_plan_2eproto; @@ -67,6 +68,14 @@ class BinaryExprDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _BinaryExpr_default_instance_; +class BinaryArithOpDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BinaryArithOp_default_instance_; +class BinaryArithOpEvalRangeExprDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BinaryArithOpEvalRangeExpr_default_instance_; class ExprDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -76,6 +85,7 @@ class ExprDefaultTypeInternal { const ::milvus::proto::plan::CompareExpr* compare_expr_; const ::milvus::proto::plan::UnaryRangeExpr* unary_range_expr_; const ::milvus::proto::plan::BinaryRangeExpr* binary_range_expr_; + const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr_; } _Expr_default_instance_; class VectorANNSDefaultTypeInternal { public: @@ -90,6 +100,38 @@ class PlanNodeDefaultTypeInternal { } // namespace plan } // namespace proto } // namespace milvus +static void InitDefaultsscc_info_BinaryArithOp_plan_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::plan::_BinaryArithOp_default_instance_; + new (ptr) ::milvus::proto::plan::BinaryArithOp(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::plan::BinaryArithOp::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_BinaryArithOp_plan_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_BinaryArithOp_plan_2eproto}, { + &scc_info_ColumnInfo_plan_2eproto.base, + &scc_info_GenericValue_plan_2eproto.base,}}; + +static void InitDefaultsscc_info_BinaryArithOpEvalRangeExpr_plan_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_; + new (ptr) ::milvus::proto::plan::BinaryArithOpEvalRangeExpr(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::plan::BinaryArithOpEvalRangeExpr::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_BinaryArithOpEvalRangeExpr_plan_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_BinaryArithOpEvalRangeExpr_plan_2eproto}, { + &scc_info_ColumnInfo_plan_2eproto.base, + &scc_info_GenericValue_plan_2eproto.base,}}; + static void InitDefaultsscc_info_BinaryExpr_plan_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -113,12 +155,13 @@ static void InitDefaultsscc_info_BinaryExpr_plan_2eproto() { ::milvus::proto::plan::Expr::InitAsDefaultInstance(); } -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_BinaryExpr_plan_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, InitDefaultsscc_info_BinaryExpr_plan_2eproto}, { +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_BinaryExpr_plan_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, InitDefaultsscc_info_BinaryExpr_plan_2eproto}, { &scc_info_TermExpr_plan_2eproto.base, &scc_info_CompareExpr_plan_2eproto.base, &scc_info_UnaryRangeExpr_plan_2eproto.base, - &scc_info_BinaryRangeExpr_plan_2eproto.base,}}; + &scc_info_BinaryRangeExpr_plan_2eproto.base, + &scc_info_BinaryArithOpEvalRangeExpr_plan_2eproto.base,}}; static void InitDefaultsscc_info_BinaryRangeExpr_plan_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -257,8 +300,8 @@ static void InitDefaultsscc_info_VectorANNS_plan_2eproto() { &scc_info_BinaryExpr_plan_2eproto.base, &scc_info_QueryInfo_plan_2eproto.base,}}; -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[12]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_plan_2eproto[3]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[14]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_plan_2eproto[4]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_plan_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { @@ -339,6 +382,24 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOB PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, left_), PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryExpr, right_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, column_info_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, arith_op_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOp, right_operand_), + ~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_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, column_info_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, arith_op_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, right_operand_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, op_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::BinaryArithOpEvalRangeExpr, value_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, _oneof_case_[0]), @@ -349,6 +410,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOB offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, compare_expr_), offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, unary_range_expr_), offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, binary_range_expr_), + offsetof(::milvus::proto::plan::ExprDefaultTypeInternal, binary_arith_op_eval_range_expr_), PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::Expr, expr_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::VectorANNS, _internal_metadata_), @@ -380,9 +442,11 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 54, -1, sizeof(::milvus::proto::plan::TermExpr)}, { 61, -1, sizeof(::milvus::proto::plan::UnaryExpr)}, { 68, -1, sizeof(::milvus::proto::plan::BinaryExpr)}, - { 76, -1, sizeof(::milvus::proto::plan::Expr)}, - { 88, -1, sizeof(::milvus::proto::plan::VectorANNS)}, - { 98, -1, sizeof(::milvus::proto::plan::PlanNode)}, + { 76, -1, sizeof(::milvus::proto::plan::BinaryArithOp)}, + { 84, -1, sizeof(::milvus::proto::plan::BinaryArithOpEvalRangeExpr)}, + { 94, -1, sizeof(::milvus::proto::plan::Expr)}, + { 107, -1, sizeof(::milvus::proto::plan::VectorANNS)}, + { 117, -1, sizeof(::milvus::proto::plan::PlanNode)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -395,6 +459,8 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::proto::plan::_TermExpr_default_instance_), reinterpret_cast(&::milvus::proto::plan::_UnaryExpr_default_instance_), reinterpret_cast(&::milvus::proto::plan::_BinaryExpr_default_instance_), + reinterpret_cast(&::milvus::proto::plan::_BinaryArithOp_default_instance_), + reinterpret_cast(&::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_), reinterpret_cast(&::milvus::proto::plan::_Expr_default_instance_), reinterpret_cast(&::milvus::proto::plan::_VectorANNS_default_instance_), reinterpret_cast(&::milvus::proto::plan::_PlanNode_default_instance_), @@ -435,33 +501,51 @@ const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(pr "naryOp\022%\n\004left\030\002 \001(\0132\027.milvus.proto.plan" ".Expr\022&\n\005right\030\003 \001(\0132\027.milvus.proto.plan" ".Expr\"6\n\010BinaryOp\022\013\n\007Invalid\020\000\022\016\n\nLogica" - "lAnd\020\001\022\r\n\tLogicalOr\020\002\"\342\002\n\004Expr\0220\n\tterm_e" - "xpr\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.milv" - "us.proto.plan.BinaryExprH\000\0226\n\014compare_ex" - "pr\030\004 \001(\0132\036.milvus.proto.plan.CompareExpr" - "H\000\022=\n\020unary_range_expr\030\005 \001(\0132!.milvus.pr" - "oto.plan.UnaryRangeExprH\000\022\?\n\021binary_rang" - "e_expr\030\006 \001(\0132\".milvus.proto.plan.BinaryR" - "angeExprH\000B\006\n\004expr\"\251\001\n\nVectorANNS\022\021\n\tis_" - "binary\030\001 \001(\010\022\020\n\010field_id\030\002 \001(\003\022+\n\npredic" - "ates\030\003 \001(\0132\027.milvus.proto.plan.Expr\0220\n\nq" - "uery_info\030\004 \001(\0132\034.milvus.proto.plan.Quer" - "yInfo\022\027\n\017placeholder_tag\030\005 \001(\t\"\221\001\n\010PlanN" - "ode\0224\n\013vector_anns\030\001 \001(\0132\035.milvus.proto." - "plan.VectorANNSH\000\022-\n\npredicates\030\002 \001(\0132\027." - "milvus.proto.plan.ExprH\000\022\030\n\020output_field" - "_ids\030\003 \003(\003B\006\n\004node*n\n\006OpType\022\013\n\007Invalid\020" - "\000\022\017\n\013GreaterThan\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010" - "LessThan\020\003\022\r\n\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010" - "NotEqual\020\006B3Z1github.com/milvus-io/milvu" - "s/internal/proto/planpbb\006proto3" + "lAnd\020\001\022\r\n\tLogicalOr\020\002\"\255\001\n\rBinaryArithOp\022" + "2\n\013column_info\030\001 \001(\0132\035.milvus.proto.plan" + ".ColumnInfo\0220\n\010arith_op\030\002 \001(\0162\036.milvus.p" + "roto.plan.ArithOpType\0226\n\rright_operand\030\003" + " \001(\0132\037.milvus.proto.plan.GenericValue\"\221\002" + "\n\032BinaryArithOpEvalRangeExpr\0222\n\013column_i" + "nfo\030\001 \001(\0132\035.milvus.proto.plan.ColumnInfo" + "\0220\n\010arith_op\030\002 \001(\0162\036.milvus.proto.plan.A" + "rithOpType\0226\n\rright_operand\030\003 \001(\0132\037.milv" + "us.proto.plan.GenericValue\022%\n\002op\030\004 \001(\0162\031" + ".milvus.proto.plan.OpType\022.\n\005value\030\005 \001(\013" + "2\037.milvus.proto.plan.GenericValue\"\274\003\n\004Ex" + "pr\0220\n\tterm_expr\030\001 \001(\0132\033.milvus.proto.pla" + "n.TermExprH\000\0222\n\nunary_expr\030\002 \001(\0132\034.milvu" + "s.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(\013" + "2!.milvus.proto.plan.UnaryRangeExprH\000\022\?\n" + "\021binary_range_expr\030\006 \001(\0132\".milvus.proto." + "plan.BinaryRangeExprH\000\022X\n\037binary_arith_o" + "p_eval_range_expr\030\007 \001(\0132-.milvus.proto.p" + "lan.BinaryArithOpEvalRangeExprH\000B\006\n\004expr" + "\"\251\001\n\nVectorANNS\022\021\n\tis_binary\030\001 \001(\010\022\020\n\010fi" + "eld_id\030\002 \001(\003\022+\n\npredicates\030\003 \001(\0132\027.milvu" + "s.proto.plan.Expr\0220\n\nquery_info\030\004 \001(\0132\034." + "milvus.proto.plan.QueryInfo\022\027\n\017placehold" + "er_tag\030\005 \001(\t\"\221\001\n\010PlanNode\0224\n\013vector_anns" + "\030\001 \001(\0132\035.milvus.proto.plan.VectorANNSH\000\022" + "-\n\npredicates\030\002 \001(\0132\027.milvus.proto.plan." + "ExprH\000\022\030\n\020output_field_ids\030\003 \003(\003B\006\n\004node" + "*n\n\006OpType\022\013\n\007Invalid\020\000\022\017\n\013GreaterThan\020\001" + "\022\020\n\014GreaterEqual\020\002\022\014\n\010LessThan\020\003\022\r\n\tLess" + "Equal\020\004\022\t\n\005Equal\020\005\022\014\n\010NotEqual\020\006*G\n\013Arit" + "hOpType\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\005B3Z1github.com/" + "milvus-io/milvus/internal/proto/planpbb\006" + "proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[1] = { &::descriptor_table_schema_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_plan_2eproto_sccs[10] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_plan_2eproto_sccs[12] = { + &scc_info_BinaryArithOp_plan_2eproto.base, + &scc_info_BinaryArithOpEvalRangeExpr_plan_2eproto.base, &scc_info_BinaryExpr_plan_2eproto.base, &scc_info_BinaryRangeExpr_plan_2eproto.base, &scc_info_ColumnInfo_plan_2eproto.base, @@ -476,10 +560,10 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_pla static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_plan_2eproto_once; static bool descriptor_table_plan_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto = { - &descriptor_table_plan_2eproto_initialized, descriptor_table_protodef_plan_2eproto, "plan.proto", 2231, - &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_sccs, descriptor_table_plan_2eproto_deps, 10, 1, + &descriptor_table_plan_2eproto_initialized, descriptor_table_protodef_plan_2eproto, "plan.proto", 2846, + &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_sccs, descriptor_table_plan_2eproto_deps, 12, 1, schemas, file_default_instances, TableStruct_plan_2eproto::offsets, - file_level_metadata_plan_2eproto, 12, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto, + file_level_metadata_plan_2eproto, 14, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. @@ -550,6 +634,24 @@ bool OpType_IsValid(int value) { } } +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ArithOpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_plan_2eproto); + return file_level_enum_descriptors_plan_2eproto[3]; +} +bool ArithOpType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + // =================================================================== @@ -4028,6 +4130,859 @@ void BinaryExpr::InternalSwap(BinaryExpr* other) { } +// =================================================================== + +void BinaryArithOp::InitAsDefaultInstance() { + ::milvus::proto::plan::_BinaryArithOp_default_instance_._instance.get_mutable()->column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>( + ::milvus::proto::plan::ColumnInfo::internal_default_instance()); + ::milvus::proto::plan::_BinaryArithOp_default_instance_._instance.get_mutable()->right_operand_ = const_cast< ::milvus::proto::plan::GenericValue*>( + ::milvus::proto::plan::GenericValue::internal_default_instance()); +} +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->column_info_; +} +const ::milvus::proto::plan::GenericValue& +BinaryArithOp::_Internal::right_operand(const BinaryArithOp* msg) { + return *msg->right_operand_; +} +BinaryArithOp::BinaryArithOp() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.plan.BinaryArithOp) +} +BinaryArithOp::BinaryArithOp(const BinaryArithOp& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_column_info()) { + column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.column_info_); + } else { + column_info_ = nullptr; + } + if (from.has_right_operand()) { + right_operand_ = new ::milvus::proto::plan::GenericValue(*from.right_operand_); + } else { + right_operand_ = nullptr; + } + arith_op_ = from.arith_op_; + // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryArithOp) +} + +void BinaryArithOp::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinaryArithOp_plan_2eproto.base); + ::memset(&column_info_, 0, static_cast( + reinterpret_cast(&arith_op_) - + reinterpret_cast(&column_info_)) + sizeof(arith_op_)); +} + +BinaryArithOp::~BinaryArithOp() { + // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryArithOp) + SharedDtor(); +} + +void BinaryArithOp::SharedDtor() { + if (this != internal_default_instance()) delete column_info_; + if (this != internal_default_instance()) delete right_operand_; +} + +void BinaryArithOp::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BinaryArithOp& BinaryArithOp::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinaryArithOp_plan_2eproto.base); + return *internal_default_instance(); +} + + +void BinaryArithOp::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.BinaryArithOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) { + delete column_info_; + } + column_info_ = nullptr; + if (GetArenaNoVirtual() == nullptr && right_operand_ != nullptr) { + delete right_operand_; + } + right_operand_ = nullptr; + arith_op_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BinaryArithOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.proto.plan.ColumnInfo column_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_column_info(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.proto.plan.ArithOpType arith_op = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_right_operand(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool BinaryArithOp::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.proto.plan.BinaryArithOp) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.proto.plan.ColumnInfo column_info = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_column_info())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_arith_op(static_cast< ::milvus::proto::plan::ArithOpType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_right_operand())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.proto.plan.BinaryArithOp) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.plan.BinaryArithOp) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BinaryArithOp::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.plan.BinaryArithOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.plan.ColumnInfo column_info = 1; + if (this->has_column_info()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::column_info(this), output); + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + if (this->arith_op() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 2, this->arith_op(), output); + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + if (this->has_right_operand()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::right_operand(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.proto.plan.BinaryArithOp) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BinaryArithOp::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryArithOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.plan.ColumnInfo column_info = 1; + if (this->has_column_info()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::column_info(this), target); + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + if (this->arith_op() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->arith_op(), target); + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + if (this->has_right_operand()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::right_operand(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryArithOp) + return target; +} + +size_t BinaryArithOp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.BinaryArithOp) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .milvus.proto.plan.ColumnInfo column_info = 1; + if (this->has_column_info()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *column_info_); + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + if (this->has_right_operand()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *right_operand_); + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + if (this->arith_op() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->arith_op()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BinaryArithOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.BinaryArithOp) + GOOGLE_DCHECK_NE(&from, this); + const BinaryArithOp* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.BinaryArithOp) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.BinaryArithOp) + MergeFrom(*source); + } +} + +void BinaryArithOp::MergeFrom(const BinaryArithOp& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryArithOp) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_column_info()) { + mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.column_info()); + } + if (from.has_right_operand()) { + mutable_right_operand()->::milvus::proto::plan::GenericValue::MergeFrom(from.right_operand()); + } + if (from.arith_op() != 0) { + set_arith_op(from.arith_op()); + } +} + +void BinaryArithOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.BinaryArithOp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +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_.Swap(&other->_internal_metadata_); + swap(column_info_, other->column_info_); + swap(right_operand_, other->right_operand_); + swap(arith_op_, other->arith_op_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BinaryArithOp::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BinaryArithOpEvalRangeExpr::InitAsDefaultInstance() { + ::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_._instance.get_mutable()->column_info_ = const_cast< ::milvus::proto::plan::ColumnInfo*>( + ::milvus::proto::plan::ColumnInfo::internal_default_instance()); + ::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_._instance.get_mutable()->right_operand_ = const_cast< ::milvus::proto::plan::GenericValue*>( + ::milvus::proto::plan::GenericValue::internal_default_instance()); + ::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_._instance.get_mutable()->value_ = const_cast< ::milvus::proto::plan::GenericValue*>( + ::milvus::proto::plan::GenericValue::internal_default_instance()); +} +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->column_info_; +} +const ::milvus::proto::plan::GenericValue& +BinaryArithOpEvalRangeExpr::_Internal::right_operand(const BinaryArithOpEvalRangeExpr* msg) { + return *msg->right_operand_; +} +const ::milvus::proto::plan::GenericValue& +BinaryArithOpEvalRangeExpr::_Internal::value(const BinaryArithOpEvalRangeExpr* msg) { + return *msg->value_; +} +BinaryArithOpEvalRangeExpr::BinaryArithOpEvalRangeExpr() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.plan.BinaryArithOpEvalRangeExpr) +} +BinaryArithOpEvalRangeExpr::BinaryArithOpEvalRangeExpr(const BinaryArithOpEvalRangeExpr& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_column_info()) { + column_info_ = new ::milvus::proto::plan::ColumnInfo(*from.column_info_); + } else { + column_info_ = nullptr; + } + if (from.has_right_operand()) { + right_operand_ = new ::milvus::proto::plan::GenericValue(*from.right_operand_); + } else { + right_operand_ = nullptr; + } + if (from.has_value()) { + value_ = new ::milvus::proto::plan::GenericValue(*from.value_); + } else { + value_ = nullptr; + } + ::memcpy(&arith_op_, &from.arith_op_, + static_cast(reinterpret_cast(&op_) - + reinterpret_cast(&arith_op_)) + sizeof(op_)); + // @@protoc_insertion_point(copy_constructor:milvus.proto.plan.BinaryArithOpEvalRangeExpr) +} + +void BinaryArithOpEvalRangeExpr::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinaryArithOpEvalRangeExpr_plan_2eproto.base); + ::memset(&column_info_, 0, static_cast( + reinterpret_cast(&op_) - + reinterpret_cast(&column_info_)) + sizeof(op_)); +} + +BinaryArithOpEvalRangeExpr::~BinaryArithOpEvalRangeExpr() { + // @@protoc_insertion_point(destructor:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + SharedDtor(); +} + +void BinaryArithOpEvalRangeExpr::SharedDtor() { + if (this != internal_default_instance()) delete column_info_; + if (this != internal_default_instance()) delete right_operand_; + if (this != internal_default_instance()) delete value_; +} + +void BinaryArithOpEvalRangeExpr::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BinaryArithOpEvalRangeExpr& BinaryArithOpEvalRangeExpr::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinaryArithOpEvalRangeExpr_plan_2eproto.base); + return *internal_default_instance(); +} + + +void BinaryArithOpEvalRangeExpr::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) { + delete column_info_; + } + column_info_ = nullptr; + if (GetArenaNoVirtual() == nullptr && right_operand_ != nullptr) { + delete right_operand_; + } + right_operand_ = nullptr; + if (GetArenaNoVirtual() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; + ::memset(&arith_op_, 0, static_cast( + reinterpret_cast(&op_) - + reinterpret_cast(&arith_op_)) + sizeof(op_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BinaryArithOpEvalRangeExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.proto.plan.ColumnInfo column_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_column_info(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.proto.plan.ArithOpType arith_op = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_op(static_cast<::milvus::proto::plan::OpType>(val)); + } else goto handle_unusual; + continue; + // .milvus.proto.plan.GenericValue value = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool BinaryArithOpEvalRangeExpr::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.proto.plan.ColumnInfo column_info = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_column_info())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_arith_op(static_cast< ::milvus::proto::plan::ArithOpType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_right_operand())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.plan.OpType op = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_op(static_cast< ::milvus::proto::plan::OpType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.plan.GenericValue value = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_value())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BinaryArithOpEvalRangeExpr::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.plan.ColumnInfo column_info = 1; + if (this->has_column_info()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::column_info(this), output); + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + if (this->arith_op() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 2, this->arith_op(), output); + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + if (this->has_right_operand()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::right_operand(this), output); + } + + // .milvus.proto.plan.OpType op = 4; + if (this->op() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 4, this->op(), output); + } + + // .milvus.proto.plan.GenericValue value = 5; + if (this->has_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, _Internal::value(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.proto.plan.BinaryArithOpEvalRangeExpr) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BinaryArithOpEvalRangeExpr::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.plan.ColumnInfo column_info = 1; + if (this->has_column_info()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::column_info(this), target); + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + if (this->arith_op() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->arith_op(), target); + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + if (this->has_right_operand()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::right_operand(this), target); + } + + // .milvus.proto.plan.OpType op = 4; + if (this->op() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->op(), target); + } + + // .milvus.proto.plan.GenericValue value = 5; + if (this->has_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, _Internal::value(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + return target; +} + +size_t BinaryArithOpEvalRangeExpr::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .milvus.proto.plan.ColumnInfo column_info = 1; + if (this->has_column_info()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *column_info_); + } + + // .milvus.proto.plan.GenericValue right_operand = 3; + if (this->has_right_operand()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *right_operand_); + } + + // .milvus.proto.plan.GenericValue value = 5; + if (this->has_value()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); + } + + // .milvus.proto.plan.ArithOpType arith_op = 2; + if (this->arith_op() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->arith_op()); + } + + // .milvus.proto.plan.OpType op = 4; + if (this->op() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->op()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BinaryArithOpEvalRangeExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + GOOGLE_DCHECK_NE(&from, this); + const BinaryArithOpEvalRangeExpr* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + MergeFrom(*source); + } +} + +void BinaryArithOpEvalRangeExpr::MergeFrom(const BinaryArithOpEvalRangeExpr& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_column_info()) { + mutable_column_info()->::milvus::proto::plan::ColumnInfo::MergeFrom(from.column_info()); + } + if (from.has_right_operand()) { + mutable_right_operand()->::milvus::proto::plan::GenericValue::MergeFrom(from.right_operand()); + } + if (from.has_value()) { + mutable_value()->::milvus::proto::plan::GenericValue::MergeFrom(from.value()); + } + if (from.arith_op() != 0) { + set_arith_op(from.arith_op()); + } + if (from.op() != 0) { + set_op(from.op()); + } +} + +void BinaryArithOpEvalRangeExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +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_.Swap(&other->_internal_metadata_); + swap(column_info_, other->column_info_); + swap(right_operand_, other->right_operand_); + swap(value_, other->value_); + swap(arith_op_, other->arith_op_); + swap(op_, other->op_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BinaryArithOpEvalRangeExpr::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== void Expr::InitAsDefaultInstance() { @@ -4043,6 +4998,8 @@ void Expr::InitAsDefaultInstance() { ::milvus::proto::plan::UnaryRangeExpr::internal_default_instance()); ::milvus::proto::plan::_Expr_default_instance_.binary_range_expr_ = const_cast< ::milvus::proto::plan::BinaryRangeExpr*>( ::milvus::proto::plan::BinaryRangeExpr::internal_default_instance()); + ::milvus::proto::plan::_Expr_default_instance_.binary_arith_op_eval_range_expr_ = const_cast< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr*>( + ::milvus::proto::plan::BinaryArithOpEvalRangeExpr::internal_default_instance()); } class Expr::_Internal { public: @@ -4052,6 +5009,7 @@ class Expr::_Internal { 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); }; const ::milvus::proto::plan::TermExpr& @@ -4078,6 +5036,10 @@ const ::milvus::proto::plan::BinaryRangeExpr& Expr::_Internal::binary_range_expr(const Expr* msg) { return *msg->expr_.binary_range_expr_; } +const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& +Expr::_Internal::binary_arith_op_eval_range_expr(const Expr* msg) { + return *msg->expr_.binary_arith_op_eval_range_expr_; +} void Expr::set_allocated_term_expr(::milvus::proto::plan::TermExpr* term_expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); clear_expr(); @@ -4162,6 +5124,20 @@ void Expr::set_allocated_binary_range_expr(::milvus::proto::plan::BinaryRangeExp } // @@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 = GetArenaNoVirtual(); + clear_expr(); + if (binary_arith_op_eval_range_expr) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + 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(); + 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) +} Expr::Expr() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); @@ -4197,6 +5173,10 @@ Expr::Expr(const Expr& from) mutable_binary_range_expr()->::milvus::proto::plan::BinaryRangeExpr::MergeFrom(from.binary_range_expr()); break; } + case kBinaryArithOpEvalRangeExpr: { + mutable_binary_arith_op_eval_range_expr()->::milvus::proto::plan::BinaryArithOpEvalRangeExpr::MergeFrom(from.binary_arith_op_eval_range_expr()); + break; + } case EXPR_NOT_SET: { break; } @@ -4256,6 +5236,10 @@ void Expr::clear_expr() { delete expr_.binary_range_expr_; break; } + case kBinaryArithOpEvalRangeExpr: { + delete expr_.binary_arith_op_eval_range_expr_; + break; + } case EXPR_NOT_SET: { break; } @@ -4324,6 +5308,13 @@ const char* Expr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter 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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(mutable_binary_arith_op_eval_range_expr(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { @@ -4420,6 +5411,17 @@ bool Expr::MergePartialFromCodedStream( break; } + // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_binary_arith_op_eval_range_expr())); + } else { + goto handle_unusual; + } + break; + } + default: { handle_unusual: if (tag == 0) { @@ -4483,6 +5485,12 @@ void Expr::SerializeWithCachedSizes( 6, _Internal::binary_range_expr(this), output); } + // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; + if (has_binary_arith_op_eval_range_expr()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, _Internal::binary_arith_op_eval_range_expr(this), output); + } + if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); @@ -4538,6 +5546,13 @@ void Expr::SerializeWithCachedSizes( 6, _Internal::binary_range_expr(this), target); } + // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; + if (has_binary_arith_op_eval_range_expr()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 7, _Internal::binary_arith_op_eval_range_expr(this), target); + } + if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); @@ -4602,6 +5617,13 @@ size_t Expr::ByteSizeLong() const { *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( + *expr_.binary_arith_op_eval_range_expr_); + break; + } case EXPR_NOT_SET: { break; } @@ -4658,6 +5680,10 @@ void Expr::MergeFrom(const Expr& from) { mutable_binary_range_expr()->::milvus::proto::plan::BinaryRangeExpr::MergeFrom(from.binary_range_expr()); break; } + case kBinaryArithOpEvalRangeExpr: { + mutable_binary_arith_op_eval_range_expr()->::milvus::proto::plan::BinaryArithOpEvalRangeExpr::MergeFrom(from.binary_arith_op_eval_range_expr()); + break; + } case EXPR_NOT_SET: { break; } @@ -5653,6 +6679,12 @@ template<> PROTOBUF_NOINLINE ::milvus::proto::plan::UnaryExpr* Arena::CreateMayb template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryExpr >(Arena* arena) { return Arena::CreateInternal< ::milvus::proto::plan::BinaryExpr >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryArithOp* Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryArithOp >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::plan::BinaryArithOp >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Arena::CreateMaybeMessage< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr >(arena); +} template<> PROTOBUF_NOINLINE ::milvus::proto::plan::Expr* Arena::CreateMaybeMessage< ::milvus::proto::plan::Expr >(Arena* arena) { return Arena::CreateInternal< ::milvus::proto::plan::Expr >(arena); } diff --git a/internal/core/src/pb/plan.pb.h b/internal/core/src/pb/plan.pb.h index 25e57fb1be..761d6e4e26 100644 --- a/internal/core/src/pb/plan.pb.h +++ b/internal/core/src/pb/plan.pb.h @@ -49,7 +49,7 @@ struct TableStruct_plan_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -59,6 +59,12 @@ extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table namespace milvus { namespace proto { namespace plan { +class BinaryArithOp; +class BinaryArithOpDefaultTypeInternal; +extern BinaryArithOpDefaultTypeInternal _BinaryArithOp_default_instance_; +class BinaryArithOpEvalRangeExpr; +class BinaryArithOpEvalRangeExprDefaultTypeInternal; +extern BinaryArithOpEvalRangeExprDefaultTypeInternal _BinaryArithOpEvalRangeExpr_default_instance_; class BinaryExpr; class BinaryExprDefaultTypeInternal; extern BinaryExprDefaultTypeInternal _BinaryExpr_default_instance_; @@ -99,6 +105,8 @@ extern VectorANNSDefaultTypeInternal _VectorANNS_default_instance_; } // namespace proto } // namespace milvus PROTOBUF_NAMESPACE_OPEN +template<> ::milvus::proto::plan::BinaryArithOp* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryArithOp>(Arena*); +template<> ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryArithOpEvalRangeExpr>(Arena*); template<> ::milvus::proto::plan::BinaryExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryExpr>(Arena*); template<> ::milvus::proto::plan::BinaryRangeExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::BinaryRangeExpr>(Arena*); template<> ::milvus::proto::plan::ColumnInfo* Arena::CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(Arena*); @@ -197,6 +205,35 @@ inline bool OpType_Parse( return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( OpType_descriptor(), name, value); } +enum ArithOpType : int { + Unknown = 0, + Add = 1, + Sub = 2, + Mul = 3, + Div = 4, + Mod = 5, + ArithOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + ArithOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool ArithOpType_IsValid(int value); +constexpr ArithOpType ArithOpType_MIN = Unknown; +constexpr ArithOpType ArithOpType_MAX = Mod; +constexpr int ArithOpType_ARRAYSIZE = ArithOpType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ArithOpType_descriptor(); +template +inline const std::string& ArithOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ArithOpType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ArithOpType_descriptor(), enum_t_value); +} +inline bool ArithOpType_Parse( + const std::string& name, ArithOpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ArithOpType_descriptor(), name, value); +} // =================================================================== class GenericValue : @@ -1678,6 +1715,325 @@ class BinaryExpr : }; // ------------------------------------------------------------------- +class BinaryArithOp : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.plan.BinaryArithOp) */ { + public: + BinaryArithOp(); + virtual ~BinaryArithOp(); + + BinaryArithOp(const BinaryArithOp& from); + BinaryArithOp(BinaryArithOp&& from) noexcept + : BinaryArithOp() { + *this = ::std::move(from); + } + + inline BinaryArithOp& operator=(const BinaryArithOp& from) { + CopyFrom(from); + return *this; + } + inline BinaryArithOp& operator=(BinaryArithOp&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BinaryArithOp& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BinaryArithOp* internal_default_instance() { + return reinterpret_cast( + &_BinaryArithOp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(BinaryArithOp& a, BinaryArithOp& b) { + a.Swap(&b); + } + inline void Swap(BinaryArithOp* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BinaryArithOp* New() const final { + return CreateMaybeMessage(nullptr); + } + + BinaryArithOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BinaryArithOp& from); + void MergeFrom(const BinaryArithOp& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BinaryArithOp* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.plan.BinaryArithOp"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_plan_2eproto); + return ::descriptor_table_plan_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kColumnInfoFieldNumber = 1, + kRightOperandFieldNumber = 3, + kArithOpFieldNumber = 2, + }; + // .milvus.proto.plan.ColumnInfo column_info = 1; + bool has_column_info() const; + void clear_column_info(); + const ::milvus::proto::plan::ColumnInfo& column_info() const; + ::milvus::proto::plan::ColumnInfo* release_column_info(); + ::milvus::proto::plan::ColumnInfo* mutable_column_info(); + void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info); + + // .milvus.proto.plan.GenericValue right_operand = 3; + bool has_right_operand() const; + void clear_right_operand(); + const ::milvus::proto::plan::GenericValue& right_operand() const; + ::milvus::proto::plan::GenericValue* release_right_operand(); + ::milvus::proto::plan::GenericValue* mutable_right_operand(); + void set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand); + + // .milvus.proto.plan.ArithOpType arith_op = 2; + void clear_arith_op(); + ::milvus::proto::plan::ArithOpType arith_op() const; + void set_arith_op(::milvus::proto::plan::ArithOpType value); + + // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryArithOp) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::milvus::proto::plan::ColumnInfo* column_info_; + ::milvus::proto::plan::GenericValue* right_operand_; + int arith_op_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_plan_2eproto; +}; +// ------------------------------------------------------------------- + +class BinaryArithOpEvalRangeExpr : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.plan.BinaryArithOpEvalRangeExpr) */ { + public: + BinaryArithOpEvalRangeExpr(); + virtual ~BinaryArithOpEvalRangeExpr(); + + BinaryArithOpEvalRangeExpr(const BinaryArithOpEvalRangeExpr& from); + BinaryArithOpEvalRangeExpr(BinaryArithOpEvalRangeExpr&& from) noexcept + : BinaryArithOpEvalRangeExpr() { + *this = ::std::move(from); + } + + inline BinaryArithOpEvalRangeExpr& operator=(const BinaryArithOpEvalRangeExpr& from) { + CopyFrom(from); + return *this; + } + inline BinaryArithOpEvalRangeExpr& operator=(BinaryArithOpEvalRangeExpr&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BinaryArithOpEvalRangeExpr& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BinaryArithOpEvalRangeExpr* internal_default_instance() { + return reinterpret_cast( + &_BinaryArithOpEvalRangeExpr_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(BinaryArithOpEvalRangeExpr& a, BinaryArithOpEvalRangeExpr& b) { + a.Swap(&b); + } + inline void Swap(BinaryArithOpEvalRangeExpr* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BinaryArithOpEvalRangeExpr* New() const final { + return CreateMaybeMessage(nullptr); + } + + BinaryArithOpEvalRangeExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BinaryArithOpEvalRangeExpr& from); + void MergeFrom(const BinaryArithOpEvalRangeExpr& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BinaryArithOpEvalRangeExpr* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.plan.BinaryArithOpEvalRangeExpr"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_plan_2eproto); + return ::descriptor_table_plan_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kColumnInfoFieldNumber = 1, + kRightOperandFieldNumber = 3, + kValueFieldNumber = 5, + kArithOpFieldNumber = 2, + kOpFieldNumber = 4, + }; + // .milvus.proto.plan.ColumnInfo column_info = 1; + bool has_column_info() const; + void clear_column_info(); + const ::milvus::proto::plan::ColumnInfo& column_info() const; + ::milvus::proto::plan::ColumnInfo* release_column_info(); + ::milvus::proto::plan::ColumnInfo* mutable_column_info(); + void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info); + + // .milvus.proto.plan.GenericValue right_operand = 3; + bool has_right_operand() const; + void clear_right_operand(); + const ::milvus::proto::plan::GenericValue& right_operand() const; + ::milvus::proto::plan::GenericValue* release_right_operand(); + ::milvus::proto::plan::GenericValue* mutable_right_operand(); + void set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand); + + // .milvus.proto.plan.GenericValue value = 5; + bool has_value() const; + void clear_value(); + const ::milvus::proto::plan::GenericValue& value() const; + ::milvus::proto::plan::GenericValue* release_value(); + ::milvus::proto::plan::GenericValue* mutable_value(); + void set_allocated_value(::milvus::proto::plan::GenericValue* value); + + // .milvus.proto.plan.ArithOpType arith_op = 2; + void clear_arith_op(); + ::milvus::proto::plan::ArithOpType arith_op() const; + void set_arith_op(::milvus::proto::plan::ArithOpType value); + + // .milvus.proto.plan.OpType op = 4; + void clear_op(); + ::milvus::proto::plan::OpType op() const; + void set_op(::milvus::proto::plan::OpType value); + + // @@protoc_insertion_point(class_scope:milvus.proto.plan.BinaryArithOpEvalRangeExpr) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::milvus::proto::plan::ColumnInfo* column_info_; + ::milvus::proto::plan::GenericValue* right_operand_; + ::milvus::proto::plan::GenericValue* value_; + int arith_op_; + int op_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_plan_2eproto; +}; +// ------------------------------------------------------------------- + class Expr : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.plan.Expr) */ { public: @@ -1721,6 +2077,7 @@ class Expr : kCompareExpr = 4, kUnaryRangeExpr = 5, kBinaryRangeExpr = 6, + kBinaryArithOpEvalRangeExpr = 7, EXPR_NOT_SET = 0, }; @@ -1730,7 +2087,7 @@ class Expr : &_Expr_default_instance_); } static constexpr int kIndexInFileMessages = - 9; + 11; friend void swap(Expr& a, Expr& b) { a.Swap(&b); @@ -1807,6 +2164,7 @@ class Expr : kCompareExprFieldNumber = 4, kUnaryRangeExprFieldNumber = 5, kBinaryRangeExprFieldNumber = 6, + kBinaryArithOpEvalRangeExprFieldNumber = 7, }; // .milvus.proto.plan.TermExpr term_expr = 1; bool has_term_expr() const; @@ -1856,6 +2214,14 @@ class Expr : ::milvus::proto::plan::BinaryRangeExpr* mutable_binary_range_expr(); void set_allocated_binary_range_expr(::milvus::proto::plan::BinaryRangeExpr* binary_range_expr); + // .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; + bool has_binary_arith_op_eval_range_expr() const; + void clear_binary_arith_op_eval_range_expr(); + const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& binary_arith_op_eval_range_expr() const; + ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* release_binary_arith_op_eval_range_expr(); + ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* mutable_binary_arith_op_eval_range_expr(); + void set_allocated_binary_arith_op_eval_range_expr(::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr); + void clear_expr(); ExprCase expr_case() const; // @@protoc_insertion_point(class_scope:milvus.proto.plan.Expr) @@ -1867,6 +2233,7 @@ class Expr : void set_has_compare_expr(); void set_has_unary_range_expr(); void set_has_binary_range_expr(); + void set_has_binary_arith_op_eval_range_expr(); inline bool has_expr() const; inline void clear_has_expr(); @@ -1880,6 +2247,7 @@ class Expr : ::milvus::proto::plan::CompareExpr* compare_expr_; ::milvus::proto::plan::UnaryRangeExpr* unary_range_expr_; ::milvus::proto::plan::BinaryRangeExpr* binary_range_expr_; + ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* binary_arith_op_eval_range_expr_; } expr_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -1930,7 +2298,7 @@ class VectorANNS : &_VectorANNS_default_instance_); } static constexpr int kIndexInFileMessages = - 10; + 12; friend void swap(VectorANNS& a, VectorANNS& b) { a.Swap(&b); @@ -2107,7 +2475,7 @@ class PlanNode : &_PlanNode_default_instance_); } static constexpr int kIndexInFileMessages = - 11; + 13; friend void swap(PlanNode& a, PlanNode& b) { a.Swap(&b); @@ -3325,6 +3693,311 @@ inline void BinaryExpr::set_allocated_right(::milvus::proto::plan::Expr* right) // ------------------------------------------------------------------- +// BinaryArithOp + +// .milvus.proto.plan.ColumnInfo column_info = 1; +inline bool BinaryArithOp::has_column_info() const { + return this != internal_default_instance() && column_info_ != nullptr; +} +inline void BinaryArithOp::clear_column_info() { + if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) { + delete column_info_; + } + column_info_ = nullptr; +} +inline const ::milvus::proto::plan::ColumnInfo& BinaryArithOp::column_info() const { + const ::milvus::proto::plan::ColumnInfo* p = column_info_; + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOp.column_info) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::plan::_ColumnInfo_default_instance_); +} +inline ::milvus::proto::plan::ColumnInfo* BinaryArithOp::release_column_info() { + // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOp.column_info) + + ::milvus::proto::plan::ColumnInfo* temp = column_info_; + column_info_ = nullptr; + return temp; +} +inline ::milvus::proto::plan::ColumnInfo* BinaryArithOp::mutable_column_info() { + + if (column_info_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaNoVirtual()); + column_info_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOp.column_info) + return column_info_; +} +inline void BinaryArithOp::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete column_info_; + } + if (column_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, column_info, submessage_arena); + } + + } else { + + } + column_info_ = column_info; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOp.column_info) +} + +// .milvus.proto.plan.ArithOpType arith_op = 2; +inline void BinaryArithOp::clear_arith_op() { + arith_op_ = 0; +} +inline ::milvus::proto::plan::ArithOpType BinaryArithOp::arith_op() const { + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOp.arith_op) + return static_cast< ::milvus::proto::plan::ArithOpType >(arith_op_); +} +inline void BinaryArithOp::set_arith_op(::milvus::proto::plan::ArithOpType value) { + + arith_op_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithOp.arith_op) +} + +// .milvus.proto.plan.GenericValue right_operand = 3; +inline bool BinaryArithOp::has_right_operand() const { + return this != internal_default_instance() && right_operand_ != nullptr; +} +inline void BinaryArithOp::clear_right_operand() { + if (GetArenaNoVirtual() == nullptr && right_operand_ != nullptr) { + delete right_operand_; + } + right_operand_ = nullptr; +} +inline const ::milvus::proto::plan::GenericValue& BinaryArithOp::right_operand() const { + const ::milvus::proto::plan::GenericValue* p = right_operand_; + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOp.right_operand) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::plan::_GenericValue_default_instance_); +} +inline ::milvus::proto::plan::GenericValue* BinaryArithOp::release_right_operand() { + // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOp.right_operand) + + ::milvus::proto::plan::GenericValue* temp = right_operand_; + right_operand_ = nullptr; + return temp; +} +inline ::milvus::proto::plan::GenericValue* BinaryArithOp::mutable_right_operand() { + + if (right_operand_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaNoVirtual()); + right_operand_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOp.right_operand) + return right_operand_; +} +inline void BinaryArithOp::set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete right_operand_; + } + if (right_operand) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + right_operand = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, right_operand, submessage_arena); + } + + } else { + + } + right_operand_ = right_operand; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOp.right_operand) +} + +// ------------------------------------------------------------------- + +// BinaryArithOpEvalRangeExpr + +// .milvus.proto.plan.ColumnInfo column_info = 1; +inline bool BinaryArithOpEvalRangeExpr::has_column_info() const { + return this != internal_default_instance() && column_info_ != nullptr; +} +inline void BinaryArithOpEvalRangeExpr::clear_column_info() { + if (GetArenaNoVirtual() == nullptr && column_info_ != nullptr) { + delete column_info_; + } + column_info_ = nullptr; +} +inline const ::milvus::proto::plan::ColumnInfo& BinaryArithOpEvalRangeExpr::column_info() const { + const ::milvus::proto::plan::ColumnInfo* p = column_info_; + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::plan::_ColumnInfo_default_instance_); +} +inline ::milvus::proto::plan::ColumnInfo* BinaryArithOpEvalRangeExpr::release_column_info() { + // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info) + + ::milvus::proto::plan::ColumnInfo* temp = column_info_; + column_info_ = nullptr; + return temp; +} +inline ::milvus::proto::plan::ColumnInfo* BinaryArithOpEvalRangeExpr::mutable_column_info() { + + if (column_info_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::plan::ColumnInfo>(GetArenaNoVirtual()); + column_info_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info) + return column_info_; +} +inline void BinaryArithOpEvalRangeExpr::set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete column_info_; + } + if (column_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + column_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, column_info, submessage_arena); + } + + } else { + + } + column_info_ = column_info; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info) +} + +// .milvus.proto.plan.ArithOpType arith_op = 2; +inline void BinaryArithOpEvalRangeExpr::clear_arith_op() { + arith_op_ = 0; +} +inline ::milvus::proto::plan::ArithOpType BinaryArithOpEvalRangeExpr::arith_op() const { + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.arith_op) + return static_cast< ::milvus::proto::plan::ArithOpType >(arith_op_); +} +inline void BinaryArithOpEvalRangeExpr::set_arith_op(::milvus::proto::plan::ArithOpType value) { + + arith_op_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithOpEvalRangeExpr.arith_op) +} + +// .milvus.proto.plan.GenericValue right_operand = 3; +inline bool BinaryArithOpEvalRangeExpr::has_right_operand() const { + return this != internal_default_instance() && right_operand_ != nullptr; +} +inline void BinaryArithOpEvalRangeExpr::clear_right_operand() { + if (GetArenaNoVirtual() == nullptr && right_operand_ != nullptr) { + delete right_operand_; + } + right_operand_ = nullptr; +} +inline const ::milvus::proto::plan::GenericValue& BinaryArithOpEvalRangeExpr::right_operand() const { + const ::milvus::proto::plan::GenericValue* p = right_operand_; + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::plan::_GenericValue_default_instance_); +} +inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::release_right_operand() { + // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand) + + ::milvus::proto::plan::GenericValue* temp = right_operand_; + right_operand_ = nullptr; + return temp; +} +inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::mutable_right_operand() { + + if (right_operand_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaNoVirtual()); + right_operand_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand) + return right_operand_; +} +inline void BinaryArithOpEvalRangeExpr::set_allocated_right_operand(::milvus::proto::plan::GenericValue* right_operand) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete right_operand_; + } + if (right_operand) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + right_operand = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, right_operand, submessage_arena); + } + + } else { + + } + right_operand_ = right_operand; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand) +} + +// .milvus.proto.plan.OpType op = 4; +inline void BinaryArithOpEvalRangeExpr::clear_op() { + op_ = 0; +} +inline ::milvus::proto::plan::OpType BinaryArithOpEvalRangeExpr::op() const { + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.op) + return static_cast< ::milvus::proto::plan::OpType >(op_); +} +inline void BinaryArithOpEvalRangeExpr::set_op(::milvus::proto::plan::OpType value) { + + op_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.plan.BinaryArithOpEvalRangeExpr.op) +} + +// .milvus.proto.plan.GenericValue value = 5; +inline bool BinaryArithOpEvalRangeExpr::has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline void BinaryArithOpEvalRangeExpr::clear_value() { + if (GetArenaNoVirtual() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::milvus::proto::plan::GenericValue& BinaryArithOpEvalRangeExpr::value() const { + const ::milvus::proto::plan::GenericValue* p = value_; + // @@protoc_insertion_point(field_get:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::plan::_GenericValue_default_instance_); +} +inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::release_value() { + // @@protoc_insertion_point(field_release:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value) + + ::milvus::proto::plan::GenericValue* temp = value_; + value_ = nullptr; + return temp; +} +inline ::milvus::proto::plan::GenericValue* BinaryArithOpEvalRangeExpr::mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::plan::GenericValue>(GetArenaNoVirtual()); + value_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value) + return value_; +} +inline void BinaryArithOpEvalRangeExpr::set_allocated_value(::milvus::proto::plan::GenericValue* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.BinaryArithOpEvalRangeExpr.value) +} + +// ------------------------------------------------------------------- + // Expr // .milvus.proto.plan.TermExpr term_expr = 1; @@ -3573,6 +4246,47 @@ inline ::milvus::proto::plan::BinaryRangeExpr* Expr::mutable_binary_range_expr() return expr_.binary_range_expr_; } +// .milvus.proto.plan.BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; +inline bool Expr::has_binary_arith_op_eval_range_expr() const { + return expr_case() == kBinaryArithOpEvalRangeExpr; +} +inline void Expr::set_has_binary_arith_op_eval_range_expr() { + _oneof_case_[0] = kBinaryArithOpEvalRangeExpr; +} +inline void Expr::clear_binary_arith_op_eval_range_expr() { + if (has_binary_arith_op_eval_range_expr()) { + delete expr_.binary_arith_op_eval_range_expr_; + clear_has_expr(); + } +} +inline ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Expr::release_binary_arith_op_eval_range_expr() { + // @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr) + if (has_binary_arith_op_eval_range_expr()) { + clear_has_expr(); + ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* temp = expr_.binary_arith_op_eval_range_expr_; + expr_.binary_arith_op_eval_range_expr_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::proto::plan::BinaryArithOpEvalRangeExpr& Expr::binary_arith_op_eval_range_expr() const { + // @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr) + return has_binary_arith_op_eval_range_expr() + ? *expr_.binary_arith_op_eval_range_expr_ + : *reinterpret_cast< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr*>(&::milvus::proto::plan::_BinaryArithOpEvalRangeExpr_default_instance_); +} +inline ::milvus::proto::plan::BinaryArithOpEvalRangeExpr* Expr::mutable_binary_arith_op_eval_range_expr() { + if (!has_binary_arith_op_eval_range_expr()) { + clear_expr(); + set_has_binary_arith_op_eval_range_expr(); + expr_.binary_arith_op_eval_range_expr_ = CreateMaybeMessage< ::milvus::proto::plan::BinaryArithOpEvalRangeExpr >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.binary_arith_op_eval_range_expr) + return expr_.binary_arith_op_eval_range_expr_; +} + inline bool Expr::has_expr() const { return expr_case() != EXPR_NOT_SET; } @@ -3917,6 +4631,10 @@ inline PlanNode::NodeCase PlanNode::node_case() const { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -3941,6 +4659,11 @@ template <> inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::plan::OpType>() { return ::milvus::proto::plan::OpType_descriptor(); } +template <> struct is_proto_enum< ::milvus::proto::plan::ArithOpType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::plan::ArithOpType>() { + return ::milvus::proto::plan::ArithOpType_descriptor(); +} PROTOBUF_NAMESPACE_CLOSE diff --git a/internal/core/src/query/Expr.h b/internal/core/src/query/Expr.h index 6681602fa6..4ccb820ee6 100644 --- a/internal/core/src/query/Expr.h +++ b/internal/core/src/query/Expr.h @@ -112,6 +112,49 @@ enum class OpType { NotEqual = 6, }; +enum class ArithOpType { + Unknown = 0, + Add = 1, + Sub = 2, + Mul = 3, + Div = 4, + Mod = 5, +}; + +static const std::map arith_op_mapping_ = { + // arith_op_name -> arith_op + {"add", ArithOpType::Add}, {"sub", ArithOpType::Sub}, {"mul", ArithOpType::Mul}, + {"div", ArithOpType::Div}, {"mod", ArithOpType::Mod}, +}; + +static const std::map mapping_arith_op_ = { + // arith_op_name -> arith_op + {ArithOpType::Add, "add"}, {ArithOpType::Sub, "sub"}, {ArithOpType::Mul, "mul"}, + {ArithOpType::Div, "div"}, {ArithOpType::Mod, "mod"}, +}; + +struct BinaryArithOpEvalRangeExpr : Expr { + const FieldOffset field_offset_; + const DataType data_type_; + const OpType op_type_; + const ArithOpType arith_op_; + + protected: + // prevent accidential instantiation + BinaryArithOpEvalRangeExpr() = delete; + + BinaryArithOpEvalRangeExpr(const FieldOffset field_offset, + const DataType data_type, + const OpType op_type, + const ArithOpType arith_op) + : field_offset_(field_offset), data_type_(data_type), op_type_(op_type), arith_op_(arith_op) { + } + + public: + void + accept(ExprVisitor&) override; +}; + static const std::map mapping_ = { // op_name -> op {"lt", OpType::LessThan}, {"le", OpType::LessEqual}, {"lte", OpType::LessEqual}, diff --git a/internal/core/src/query/ExprImpl.h b/internal/core/src/query/ExprImpl.h index 0c8660cd77..63398af5d7 100644 --- a/internal/core/src/query/ExprImpl.h +++ b/internal/core/src/query/ExprImpl.h @@ -33,6 +33,23 @@ struct TermExprImpl : TermExpr { } }; +template +struct BinaryArithOpEvalRangeExprImpl : BinaryArithOpEvalRangeExpr { + const T right_operand_; + const T value_; + + BinaryArithOpEvalRangeExprImpl(const FieldOffset field_offset, + const DataType data_type, + const ArithOpType arith_op, + const T right_operand, + const OpType op_type, + const T value) + : BinaryArithOpEvalRangeExpr(field_offset, data_type, op_type, arith_op), + right_operand_(right_operand), + value_(value) { + } +}; + template struct UnaryRangeExprImpl : UnaryRangeExpr { const T value_; diff --git a/internal/core/src/query/Parser.cpp b/internal/core/src/query/Parser.cpp index 5e805b9416..b824e734e7 100644 --- a/internal/core/src/query/Parser.cpp +++ b/internal/core/src/query/Parser.cpp @@ -243,6 +243,65 @@ Parser::ParseRangeNodeImpl(const FieldName& field_name, const Json& body) { auto item = body.begin(); auto op_name = boost::algorithm::to_lower_copy(std::string(item.key())); AssertInfo(mapping_.count(op_name), "op(" + op_name + ") not found"); + + // This is an expression with an arithmetic operation + if (item.value().is_object()) { + /* // This is the expected DSL expression + { + range: { + field_name: { + op: { + arith_op: { + right_operand: operand, + value: value + }, + } + } + } + } + EXAMPLE: + { + range: { + field_name: { + "EQ": { + "ADD": { + right_operand: 10, + value: 25 + }, + } + } + } + } + */ + auto arith = item.value(); + auto arith_body = arith.begin(); + + auto arith_op_name = boost::algorithm::to_lower_copy(std::string(arith_body.key())); + AssertInfo(arith_op_mapping_.count(arith_op_name), "arith op(" + arith_op_name + ") not found"); + + auto& arith_op_body = arith_body.value(); + Assert(arith_op_body.is_object()); + + auto right_operand = arith_op_body["right_operand"]; + auto value = arith_op_body["value"]; + + if constexpr (std::is_same_v) { + throw std::runtime_error("bool type is not supported"); + } else if constexpr (std::is_integral_v) { + Assert(right_operand.is_number_integer()); + Assert(value.is_number_integer()); + } else if constexpr (std::is_floating_point_v) { + Assert(right_operand.is_number()); + Assert(value.is_number()); + } else { + static_assert(always_false, "unsupported type"); + } + + return std::make_unique>( + schema.get_offset(field_name), schema[field_name].get_data_type(), arith_op_mapping_.at(arith_op_name), + right_operand, mapping_.at(op_name), value); + } + if constexpr (std::is_same_v) { Assert(item.value().is_boolean()); } else if constexpr (std::is_integral_v) { diff --git a/internal/core/src/query/PlanProto.cpp b/internal/core/src/query/PlanProto.cpp index 88308f0a52..6e71cab69a 100644 --- a/internal/core/src/query/PlanProto.cpp +++ b/internal/core/src/query/PlanProto.cpp @@ -89,6 +89,31 @@ ExtractBinaryRangeExprImpl(FieldOffset field_offset, DataType data_type, const p getValue(expr_proto.upper_value())); } +template +std::unique_ptr> +ExtractBinaryArithOpEvalRangeExprImpl(FieldOffset field_offset, + DataType data_type, + const planpb::BinaryArithOpEvalRangeExpr& expr_proto) { + static_assert(std::is_fundamental_v); + auto getValue = [&](const auto& value_proto) -> T { + if constexpr (std::is_same_v) { + // Handle bool here. Otherwise, it can go in `is_integral_v` + static_assert(always_false); + } else if constexpr (std::is_integral_v) { + Assert(value_proto.val_case() == planpb::GenericValue::kInt64Val); + return static_cast(value_proto.int64_val()); + } else if constexpr (std::is_floating_point_v) { + Assert(value_proto.val_case() == planpb::GenericValue::kFloatVal); + return static_cast(value_proto.float_val()); + } else { + static_assert(always_false); + } + }; + return std::make_unique>( + field_offset, data_type, static_cast(expr_proto.arith_op()), getValue(expr_proto.right_operand()), + static_cast(expr_proto.op()), getValue(expr_proto.value())); +} + std::unique_ptr ProtoParser::PlanNodeFromProto(const planpb::PlanNode& plan_node_proto) { // TODO: add more buffs @@ -337,6 +362,42 @@ ProtoParser::ParseBinaryExpr(const proto::plan::BinaryExpr& expr_pb) { return std::make_unique(op, left_expr, right_expr); } +ExprPtr +ProtoParser::ParseBinaryArithOpEvalRangeExpr(const proto::plan::BinaryArithOpEvalRangeExpr& expr_pb) { + auto& column_info = expr_pb.column_info(); + auto field_id = FieldId(column_info.field_id()); + auto field_offset = schema.get_offset(field_id); + auto data_type = schema[field_offset].get_data_type(); + Assert(data_type == static_cast(column_info.data_type())); + + auto result = [&]() -> ExprPtr { + switch (data_type) { + case DataType::INT8: { + return ExtractBinaryArithOpEvalRangeExprImpl(field_offset, data_type, expr_pb); + } + case DataType::INT16: { + return ExtractBinaryArithOpEvalRangeExprImpl(field_offset, data_type, expr_pb); + } + case DataType::INT32: { + return ExtractBinaryArithOpEvalRangeExprImpl(field_offset, data_type, expr_pb); + } + case DataType::INT64: { + return ExtractBinaryArithOpEvalRangeExprImpl(field_offset, data_type, expr_pb); + } + case DataType::FLOAT: { + return ExtractBinaryArithOpEvalRangeExprImpl(field_offset, data_type, expr_pb); + } + case DataType::DOUBLE: { + return ExtractBinaryArithOpEvalRangeExprImpl(field_offset, data_type, expr_pb); + } + default: { + PanicInfo("unsupported data type"); + } + } + }(); + return result; +} + ExprPtr ProtoParser::ParseExpr(const proto::plan::Expr& expr_pb) { using ppe = proto::plan::Expr; @@ -359,6 +420,9 @@ ProtoParser::ParseExpr(const proto::plan::Expr& expr_pb) { case ppe::kCompareExpr: { return ParseCompareExpr(expr_pb.compare_expr()); } + case ppe::kBinaryArithOpEvalRangeExpr: { + return ParseBinaryArithOpEvalRangeExpr(expr_pb.binary_arith_op_eval_range_expr()); + } default: PanicInfo("unsupported expr proto node"); } diff --git a/internal/core/src/query/PlanProto.h b/internal/core/src/query/PlanProto.h index 83acc48f64..9942ec529a 100644 --- a/internal/core/src/query/PlanProto.h +++ b/internal/core/src/query/PlanProto.h @@ -29,6 +29,9 @@ class ProtoParser { // ExprPtr // ExprFromProto(const proto::plan::Expr& expr_proto); + ExprPtr + ParseBinaryArithOpEvalRangeExpr(const proto::plan::BinaryArithOpEvalRangeExpr& expr_pb); + ExprPtr ParseUnaryRangeExpr(const proto::plan::UnaryRangeExpr& expr_pb); diff --git a/internal/core/src/query/generated/ExecExprVisitor.h b/internal/core/src/query/generated/ExecExprVisitor.h index 291455584c..719c778890 100644 --- a/internal/core/src/query/generated/ExecExprVisitor.h +++ b/internal/core/src/query/generated/ExecExprVisitor.h @@ -35,6 +35,9 @@ class ExecExprVisitor : public ExprVisitor { void visit(UnaryRangeExpr& expr) override; + void + visit(BinaryArithOpEvalRangeExpr& expr) override; + void visit(BinaryRangeExpr& expr) override; @@ -61,10 +64,18 @@ class ExecExprVisitor : public ExprVisitor { auto ExecRangeVisitorImpl(FieldOffset field_offset, IndexFunc func, ElementFunc element_func) -> BitsetType; + template + auto + ExecDataRangeVisitorImpl(FieldOffset field_offset, ElementFunc element_func) -> BitsetType; + template auto ExecUnaryRangeVisitorDispatcher(UnaryRangeExpr& expr_raw) -> BitsetType; + template + auto + ExecBinaryArithOpEvalRangeVisitorDispatcher(BinaryArithOpEvalRangeExpr& expr_raw) -> BitsetType; + template auto ExecBinaryRangeVisitorDispatcher(BinaryRangeExpr& expr_raw) -> BitsetType; diff --git a/internal/core/src/query/generated/Expr.cpp b/internal/core/src/query/generated/Expr.cpp index add8abe75d..9cdba3f878 100644 --- a/internal/core/src/query/generated/Expr.cpp +++ b/internal/core/src/query/generated/Expr.cpp @@ -35,6 +35,10 @@ UnaryRangeExpr::accept(ExprVisitor& visitor) { visitor.visit(*this); } +void +BinaryArithOpEvalRangeExpr::accept(ExprVisitor& visitor) { + visitor.visit(*this); +} void BinaryRangeExpr::accept(ExprVisitor& visitor) { visitor.visit(*this); diff --git a/internal/core/src/query/generated/ExprVisitor.h b/internal/core/src/query/generated/ExprVisitor.h index 4bbd63d470..5e4b6b4a07 100644 --- a/internal/core/src/query/generated/ExprVisitor.h +++ b/internal/core/src/query/generated/ExprVisitor.h @@ -31,6 +31,9 @@ class ExprVisitor { virtual void visit(UnaryRangeExpr&) = 0; + virtual void + visit(BinaryArithOpEvalRangeExpr&) = 0; + virtual void visit(BinaryRangeExpr&) = 0; diff --git a/internal/core/src/query/generated/ExtractInfoExprVisitor.h b/internal/core/src/query/generated/ExtractInfoExprVisitor.h index 91a7a3a5cc..c5996ff303 100644 --- a/internal/core/src/query/generated/ExtractInfoExprVisitor.h +++ b/internal/core/src/query/generated/ExtractInfoExprVisitor.h @@ -30,6 +30,9 @@ class ExtractInfoExprVisitor : public ExprVisitor { void visit(UnaryRangeExpr& expr) override; + void + visit(BinaryArithOpEvalRangeExpr& expr) override; + void visit(BinaryRangeExpr& expr) override; diff --git a/internal/core/src/query/generated/ShowExprVisitor.h b/internal/core/src/query/generated/ShowExprVisitor.h index bd51b65a58..6586520732 100644 --- a/internal/core/src/query/generated/ShowExprVisitor.h +++ b/internal/core/src/query/generated/ShowExprVisitor.h @@ -31,6 +31,9 @@ class ShowExprVisitor : public ExprVisitor { void visit(UnaryRangeExpr& expr) override; + void + visit(BinaryArithOpEvalRangeExpr& expr) override; + void visit(BinaryRangeExpr& expr) override; @@ -39,6 +42,7 @@ class ShowExprVisitor : public ExprVisitor { public: Json + call_child(Expr& expr) { assert(!json_opt_.has_value()); expr.accept(*this); diff --git a/internal/core/src/query/generated/VerifyExprVisitor.h b/internal/core/src/query/generated/VerifyExprVisitor.h index 2c7055b227..d975b91c79 100644 --- a/internal/core/src/query/generated/VerifyExprVisitor.h +++ b/internal/core/src/query/generated/VerifyExprVisitor.h @@ -35,6 +35,9 @@ class VerifyExprVisitor : public ExprVisitor { void visit(UnaryRangeExpr& expr) override; + void + visit(BinaryArithOpEvalRangeExpr& expr) override; + void visit(BinaryRangeExpr& expr) override; diff --git a/internal/core/src/query/visitors/ExecExprVisitor.cpp b/internal/core/src/query/visitors/ExecExprVisitor.cpp index aa91a0e4d8..bec869f836 100644 --- a/internal/core/src/query/visitors/ExecExprVisitor.cpp +++ b/internal/core/src/query/visitors/ExecExprVisitor.cpp @@ -48,6 +48,10 @@ class ExecExprVisitor : ExprVisitor { auto ExecUnaryRangeVisitorDispatcher(UnaryRangeExpr& expr_raw) -> BitsetType; + template + auto + ExecBinaryArithOpEvalRangeVisitorDispatcher(BinaryArithOpEvalRangeExpr& expr_raw) -> BitsetType; + template auto ExecBinaryRangeVisitorDispatcher(BinaryRangeExpr& expr_raw) -> BitsetType; @@ -174,6 +178,31 @@ ExecExprVisitor::ExecRangeVisitorImpl(FieldOffset field_offset, IndexFunc index_ return final_result; } +template +auto +ExecExprVisitor::ExecDataRangeVisitorImpl(FieldOffset field_offset, ElementFunc element_func) -> BitsetType { + auto& schema = segment_.get_schema(); + auto& field_meta = schema[field_offset]; + auto size_per_chunk = segment_.size_per_chunk(); + auto num_chunk = upper_div(row_count_, size_per_chunk); + std::deque results; + + for (auto chunk_id = 0; chunk_id < num_chunk; ++chunk_id) { + auto this_size = chunk_id == num_chunk - 1 ? row_count_ - chunk_id * size_per_chunk : size_per_chunk; + BitsetType result(this_size); + auto chunk = segment_.chunk_data(field_offset, chunk_id); + const T* data = chunk.data(); + for (int index = 0; index < this_size; ++index) { + result[index] = element_func(data[index]); + } + AssertInfo(result.size() == this_size, "[ExecExprVisitor]Chunk result size not equal to expected size"); + results.emplace_back(std::move(result)); + } + auto final_result = Assemble(results); + AssertInfo(final_result.size() == row_count_, "[ExecExprVisitor]Final result size not equal to row count"); + return final_result; +} + #pragma clang diagnostic push #pragma ide diagnostic ignored "Simplify" template @@ -222,6 +251,84 @@ ExecExprVisitor::ExecUnaryRangeVisitorDispatcher(UnaryRangeExpr& expr_raw) -> Bi } #pragma clang diagnostic pop +#pragma clang diagnostic push +#pragma ide diagnostic ignored "Simplify" +template +auto +ExecExprVisitor::ExecBinaryArithOpEvalRangeVisitorDispatcher(BinaryArithOpEvalRangeExpr& expr_raw) -> BitsetType { + auto& expr = static_cast&>(expr_raw); + using Index = scalar::ScalarIndex; + auto arith_op = expr.arith_op_; + auto right_operand = expr.right_operand_; + auto op = expr.op_type_; + auto val = expr.value_; + + switch (op) { + case OpType::Equal: { + switch (arith_op) { + case ArithOpType::Add: { + auto elem_func = [val, right_operand](T x) { return ((x + right_operand) == val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Sub: { + auto elem_func = [val, right_operand](T x) { return ((x - right_operand) == val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Mul: { + auto elem_func = [val, right_operand](T x) { return ((x * right_operand) == val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Div: { + auto elem_func = [val, right_operand](T x) { return ((x / right_operand) == val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Mod: { + auto elem_func = [val, right_operand](T x) { + return (static_cast(fmod(x, right_operand)) == val); + }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + default: { + PanicInfo("unsupported arithmetic operation"); + } + } + } + case OpType::NotEqual: { + switch (arith_op) { + case ArithOpType::Add: { + auto elem_func = [val, right_operand](T x) { return ((x + right_operand) != val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Sub: { + auto elem_func = [val, right_operand](T x) { return ((x - right_operand) != val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Mul: { + auto elem_func = [val, right_operand](T x) { return ((x * right_operand) != val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Div: { + auto elem_func = [val, right_operand](T x) { return ((x / right_operand) != val); }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + case ArithOpType::Mod: { + auto elem_func = [val, right_operand](T x) { + return (static_cast(fmod(x, right_operand)) != val); + }; + return ExecDataRangeVisitorImpl(expr.field_offset_, elem_func); + } + default: { + PanicInfo("unsupported arithmetic operation"); + } + } + } + default: { + PanicInfo("unsupported range node with arithmetic operation"); + } + } +} +#pragma clang diagnostic pop + #pragma clang diagnostic push #pragma ide diagnostic ignored "Simplify" template @@ -297,6 +404,44 @@ ExecExprVisitor::visit(UnaryRangeExpr& expr) { bitset_opt_ = std::move(res); } +void +ExecExprVisitor::visit(BinaryArithOpEvalRangeExpr& expr) { + auto& field_meta = segment_.get_schema()[expr.field_offset_]; + AssertInfo(expr.data_type_ == field_meta.get_data_type(), + "[ExecExprVisitor]DataType of expr isn't field_meta data type"); + BitsetType res; + switch (expr.data_type_) { + case DataType::INT8: { + res = ExecBinaryArithOpEvalRangeVisitorDispatcher(expr); + break; + } + case DataType::INT16: { + res = ExecBinaryArithOpEvalRangeVisitorDispatcher(expr); + break; + } + case DataType::INT32: { + res = ExecBinaryArithOpEvalRangeVisitorDispatcher(expr); + break; + } + case DataType::INT64: { + res = ExecBinaryArithOpEvalRangeVisitorDispatcher(expr); + break; + } + case DataType::FLOAT: { + res = ExecBinaryArithOpEvalRangeVisitorDispatcher(expr); + break; + } + case DataType::DOUBLE: { + res = ExecBinaryArithOpEvalRangeVisitorDispatcher(expr); + break; + } + default: + PanicInfo("unsupported"); + } + AssertInfo(res.size() == row_count_, "[ExecExprVisitor]Size of results not equal row count"); + bitset_opt_ = std::move(res); +} + void ExecExprVisitor::visit(BinaryRangeExpr& expr) { auto& field_meta = segment_.get_schema()[expr.field_offset_]; diff --git a/internal/core/src/query/visitors/ExtractInfoExprVisitor.cpp b/internal/core/src/query/visitors/ExtractInfoExprVisitor.cpp index dfd1d48863..ec438752c8 100644 --- a/internal/core/src/query/visitors/ExtractInfoExprVisitor.cpp +++ b/internal/core/src/query/visitors/ExtractInfoExprVisitor.cpp @@ -59,4 +59,9 @@ ExtractInfoExprVisitor::visit(CompareExpr& expr) { plan_info_.add_involved_field(expr.right_field_offset_); } +void +ExtractInfoExprVisitor::visit(BinaryArithOpEvalRangeExpr& expr) { + plan_info_.add_involved_field(expr.field_offset_); +} + } // namespace milvus::query diff --git a/internal/core/src/query/visitors/ShowExprVisitor.cpp b/internal/core/src/query/visitors/ShowExprVisitor.cpp index 18e817175c..8d38dbb67c 100644 --- a/internal/core/src/query/visitors/ShowExprVisitor.cpp +++ b/internal/core/src/query/visitors/ShowExprVisitor.cpp @@ -248,4 +248,53 @@ ShowExprVisitor::visit(CompareExpr& expr) { json_opt_ = res; } +template +static Json +BinaryArithOpEvalRangeExtract(const BinaryArithOpEvalRangeExpr& expr_raw) { + using proto::plan::ArithOpType; + using proto::plan::ArithOpType_Name; + using proto::plan::OpType; + using proto::plan::OpType_Name; + + auto expr = dynamic_cast*>(&expr_raw); + AssertInfo(expr, "[ShowExprVisitor]BinaryArithOpEvalRangeExpr cast to BinaryArithOpEvalRangeExprImpl failed"); + + Json res{{"expr_type", "BinaryArithOpEvalRange"}, + {"field_offset", expr->field_offset_.get()}, + {"data_type", datatype_name(expr->data_type_)}, + {"arith_op", ArithOpType_Name(static_cast(expr->arith_op_))}, + {"right_operand", expr->right_operand_}, + {"op", OpType_Name(static_cast(expr->op_type_))}, + {"value", expr->value_}}; + return res; +} + +void +ShowExprVisitor::visit(BinaryArithOpEvalRangeExpr& expr) { + AssertInfo(!json_opt_.has_value(), "[ShowExprVisitor]Ret json already has value before visit"); + AssertInfo(datatype_is_vector(expr.data_type_) == false, "[ShowExprVisitor]Data type of expr isn't vector type"); + switch (expr.data_type_) { + case DataType::INT8: + json_opt_ = BinaryArithOpEvalRangeExtract(expr); + return; + case DataType::INT16: + json_opt_ = BinaryArithOpEvalRangeExtract(expr); + return; + case DataType::INT32: + json_opt_ = BinaryArithOpEvalRangeExtract(expr); + return; + case DataType::INT64: + json_opt_ = BinaryArithOpEvalRangeExtract(expr); + return; + case DataType::DOUBLE: + json_opt_ = BinaryArithOpEvalRangeExtract(expr); + return; + case DataType::FLOAT: + json_opt_ = BinaryArithOpEvalRangeExtract(expr); + return; + default: + PanicInfo("unsupported type"); + } +} + } // namespace milvus::query diff --git a/internal/core/src/query/visitors/VerifyExprVisitor.cpp b/internal/core/src/query/visitors/VerifyExprVisitor.cpp index 148a45feac..305d4cc01f 100644 --- a/internal/core/src/query/visitors/VerifyExprVisitor.cpp +++ b/internal/core/src/query/visitors/VerifyExprVisitor.cpp @@ -32,6 +32,11 @@ VerifyExprVisitor::visit(UnaryRangeExpr& expr) { // TODO } +void +VerifyExprVisitor::visit(BinaryArithOpEvalRangeExpr& expr) { + // TODO +} + void VerifyExprVisitor::visit(BinaryRangeExpr& expr) { // TODO diff --git a/internal/core/unittest/test_expr.cpp b/internal/core/unittest/test_expr.cpp index 35b27fa393..91ccbaa9cb 100644 --- a/internal/core/unittest/test_expr.cpp +++ b/internal/core/unittest/test_expr.cpp @@ -581,3 +581,364 @@ TEST(Expr, TestCompare) { } } } + +TEST(Expr, TestBinaryArithOpEvalRange) { + using namespace milvus::query; + using namespace milvus::segcore; + std::vector, DataType>> testcases = { + // Add test cases for BinaryArithOpEvalRangeExpr EQ of various data types + {R"("EQ": { + "ADD": { + "right_operand": 4, + "value": 8 + } + })", [](int8_t v) { return (v + 4) == 8; }, DataType::INT8}, + {R"("EQ": { + "SUB": { + "right_operand": 500, + "value": 1500 + } + })", [](int16_t v) { return (v - 500) == 1500; }, DataType::INT16}, + {R"("EQ": { + "MUL": { + "right_operand": 2, + "value": 4000 + } + })", [](int32_t v) { return (v * 2) == 4000; }, DataType::INT32}, + {R"("EQ": { + "DIV": { + "right_operand": 2, + "value": 1000 + } + })", [](int64_t v) { return (v / 2) == 1000; }, DataType::INT64}, + {R"("EQ": { + "MOD": { + "right_operand": 100, + "value": 0 + } + })", [](int32_t v) { return (v % 100) == 0; }, DataType::INT32}, + {R"("EQ": { + "ADD": { + "right_operand": 500, + "value": 2500 + } + })", [](float v) { return (v + 500) == 2500; }, DataType::FLOAT}, + {R"("EQ": { + "ADD": { + "right_operand": 500, + "value": 2500 + } + })", [](double v) { return (v + 500) == 2500; }, DataType::DOUBLE}, + // Add test cases for BinaryArithOpEvalRangeExpr NE of various data types + {R"("NE": { + "ADD": { + "right_operand": 500, + "value": 2500 + } + })", [](float v) { return (v + 500) != 2500; }, DataType::FLOAT}, + {R"("NE": { + "SUB": { + "right_operand": 500, + "value": 2500 + } + })", [](double v) { return (v - 500) != 2500; }, DataType::DOUBLE}, + {R"("NE": { + "MUL": { + "right_operand": 2, + "value": 2 + } + })", [](int8_t v) { return (v * 2) != 2; }, DataType::INT8}, + {R"("NE": { + "DIV": { + "right_operand": 2, + "value": 1000 + } + })", [](int16_t v) { return (v / 2) != 1000; }, DataType::INT16}, + {R"("NE": { + "MOD": { + "right_operand": 100, + "value": 0 + } + })", [](int32_t v) { return (v % 100) != 0; }, DataType::INT32}, + {R"("NE": { + "ADD": { + "right_operand": 500, + "value": 2500 + } + })", [](int64_t v) { return (v + 500) != 2500; }, DataType::INT64}, + }; + + std::string dsl_string_tmp = R"({ + "bool": { + "must": [ + { + "range": { + @@@@@ + } + }, + { + "vector": { + "fakevec": { + "metric_type": "L2", + "params": { + "nprobe": 10 + }, + "query": "$0", + "topk": 10, + "round_decimal": 3 + } + } + } + ] + } + })"; + + std::string dsl_string_int8 = R"( + "age8": { + @@@@ + })"; + + std::string dsl_string_int16 = R"( + "age16": { + @@@@ + })"; + + std::string dsl_string_int32 = R"( + "age32": { + @@@@ + })"; + + std::string dsl_string_int64 = R"( + "age64": { + @@@@ + })"; + + + std::string dsl_string_float = R"( + "age_float": { + @@@@ + })"; + + std::string dsl_string_double = R"( + "age_double": { + @@@@ + })"; + + auto schema = std::make_shared(); + schema->AddDebugField("fakevec", DataType::VECTOR_FLOAT, 16, MetricType::METRIC_L2); + schema->AddDebugField("age8", DataType::INT8); + schema->AddDebugField("age16", DataType::INT16); + schema->AddDebugField("age32", DataType::INT32); + schema->AddDebugField("age64", DataType::INT64); + schema->AddDebugField("age_float", DataType::FLOAT); + schema->AddDebugField("age_double", DataType::DOUBLE); + + auto seg = CreateGrowingSegment(schema); + int N = 1000; + std::vector age8_col; + std::vector age16_col; + std::vector age32_col; + std::vector age64_col; + std::vector age_float_col; + std::vector age_double_col; + int num_iters = 100; + for (int iter = 0; iter < num_iters; ++iter) { + auto raw_data = DataGen(schema, N, iter); + + auto new_age8_col = raw_data.get_col(1); + auto new_age16_col = raw_data.get_col(2); + auto new_age32_col = raw_data.get_col(3); + auto new_age64_col = raw_data.get_col(4); + auto new_age_float_col = raw_data.get_col(5); + auto new_age_double_col = raw_data.get_col(6); + + age8_col.insert(age8_col.end(), new_age8_col.begin(), new_age8_col.end()); + age16_col.insert(age16_col.end(), new_age16_col.begin(), new_age16_col.end()); + age32_col.insert(age32_col.end(), new_age32_col.begin(), new_age32_col.end()); + age64_col.insert(age64_col.end(), new_age64_col.begin(), new_age64_col.end()); + age_float_col.insert(age_float_col.end(), new_age_float_col.begin(), new_age_float_col.end()); + age_double_col.insert(age_double_col.end(), new_age_double_col.begin(), new_age_double_col.end()); + + seg->PreInsert(N); + seg->Insert(iter * N, N, raw_data.row_ids_.data(), raw_data.timestamps_.data(), raw_data.raw_); + } + + auto seg_promote = dynamic_cast(seg.get()); + ExecExprVisitor visitor(*seg_promote, seg_promote->get_row_count(), MAX_TIMESTAMP); + for (auto [clause, ref_func, dtype] : testcases) { + auto loc = dsl_string_tmp.find("@@@@@"); + auto dsl_string = dsl_string_tmp; + if (dtype == DataType::INT8) { + dsl_string.replace(loc, 5, dsl_string_int8); + } else if (dtype == DataType::INT16) { + dsl_string.replace(loc, 5, dsl_string_int16); + } else if (dtype == DataType::INT32) { + dsl_string.replace(loc, 5, dsl_string_int32); + } else if (dtype == DataType::INT64) { + dsl_string.replace(loc, 5, dsl_string_int64); + } else if (dtype == DataType::FLOAT) { + dsl_string.replace(loc, 5, dsl_string_float); + } else if (dtype == DataType::DOUBLE) { + dsl_string.replace(loc, 5, dsl_string_double); + } else { + ASSERT_TRUE(false) << "No test case defined for this data type"; + } + loc = dsl_string.find("@@@@"); + dsl_string.replace(loc, 4, clause); + auto plan = CreatePlan(*schema, dsl_string); + auto final = visitor.call_child(*plan->plan_node_->predicate_.value()); + EXPECT_EQ(final.size(), N * num_iters); + + for (int i = 0; i < N * num_iters; ++i) { + auto ans = final[i]; + if (dtype == DataType::INT8) { + auto val = age8_col[i]; + auto ref = ref_func(val); + ASSERT_EQ(ans, ref) << clause << "@" << i << "!!" << val; + } else if (dtype == DataType::INT16) { + auto val = age16_col[i]; + auto ref = ref_func(val); + ASSERT_EQ(ans, ref) << clause << "@" << i << "!!" << val; + } else if (dtype == DataType::INT32) { + auto val = age32_col[i]; + auto ref = ref_func(val); + ASSERT_EQ(ans, ref) << clause << "@" << i << "!!" << val; + } else if (dtype == DataType::INT64) { + auto val = age64_col[i]; + auto ref = ref_func(val); + ASSERT_EQ(ans, ref) << clause << "@" << i << "!!" << val; + } else if (dtype == DataType::FLOAT) { + auto val = age_float_col[i]; + auto ref = ref_func(val); + ASSERT_EQ(ans, ref) << clause << "@" << i << "!!" << val; + } else if (dtype == DataType::DOUBLE) { + auto val = age_double_col[i]; + auto ref = ref_func(val); + ASSERT_EQ(ans, ref) << clause << "@" << i << "!!" << val; + } else { + ASSERT_TRUE(false) << "No test case defined for this data type"; + } + } + } +} + +TEST(Expr, TestBinaryArithOpEvalRangeExceptions) { + using namespace milvus::query; + using namespace milvus::segcore; + std::vector> testcases = { + // Add test for data type mismatch + {R"("EQ": { + "ADD": { + "right_operand": 500, + "value": 2500.00 + } + })", "Assert \"(value.is_number_integer())\"", DataType::INT32}, + {R"("EQ": { + "ADD": { + "right_operand": 500.0, + "value": 2500 + } + })", "Assert \"(right_operand.is_number_integer())\"", DataType::INT32}, + {R"("EQ": { + "ADD": { + "right_operand": 500.0, + "value": true + } + })", "Assert \"(value.is_number())\"", DataType::FLOAT}, + {R"("EQ": { + "ADD": { + "right_operand": "500", + "value": 2500.0 + } + })", "Assert \"(right_operand.is_number())\"", DataType::FLOAT}, + // Check unsupported arithmetic operator type + {R"("EQ": { + "EXP": { + "right_operand": 500, + "value": 2500 + } + })", "arith op(exp) not found", DataType::INT32}, + // Check unsupported data type + {R"("EQ": { + "ADD": { + "right_operand": true, + "value": false + } + })", "bool type is not supported", DataType::BOOL}, + }; + + std::string dsl_string_tmp = R"({ + "bool": { + "must": [ + { + "range": { + @@@@@ + } + }, + { + "vector": { + "fakevec": { + "metric_type": "L2", + "params": { + "nprobe": 10 + }, + "query": "$0", + "topk": 10, + "round_decimal": 3 + } + } + } + ] + } + })"; + + std::string dsl_string_int = R"( + "age": { + @@@@ + })"; + + std::string dsl_string_num = R"( + "FloatN": { + @@@@ + })"; + + std::string dsl_string_bool = R"( + "BoolField": { + @@@@ + })"; + + auto schema = std::make_shared(); + schema->AddDebugField("fakevec", DataType::VECTOR_FLOAT, 16, MetricType::METRIC_L2); + schema->AddDebugField("age", DataType::INT32); + schema->AddDebugField("FloatN", DataType::FLOAT); + schema->AddDebugField("BoolField", DataType::BOOL); + + for (auto [clause, assert_info, dtype] : testcases) { + auto loc = dsl_string_tmp.find("@@@@@"); + auto dsl_string = dsl_string_tmp; + if (dtype == DataType::INT32) { + dsl_string.replace(loc, 5, dsl_string_int); + } else if (dtype == DataType::FLOAT) { + dsl_string.replace(loc, 5, dsl_string_num); + } else if (dtype == DataType::BOOL) { + dsl_string.replace(loc, 5, dsl_string_bool); + } else { + ASSERT_TRUE(false) << "No test case defined for this data type"; + } + + loc = dsl_string.find("@@@@"); + dsl_string.replace(loc, 4, clause); + + try { + auto plan = CreatePlan(*schema, dsl_string); + FAIL() << "Expected AssertionError: " << assert_info << " not thrown"; + } + catch(const std::exception& err) { + std::string err_msg = err.what(); + ASSERT_TRUE(err_msg.find(assert_info) != std::string::npos); + } + catch(...) { + FAIL() << "Expected AssertionError: " << assert_info << " not thrown"; + } + } +} diff --git a/internal/core/unittest/test_plan_proto.cpp b/internal/core/unittest/test_plan_proto.cpp index 56e753c273..a930af96b2 100644 --- a/internal/core/unittest/test_plan_proto.cpp +++ b/internal/core/unittest/test_plan_proto.cpp @@ -543,4 +543,96 @@ vector_anns: < auto ref_plan = CreatePlan(*schema, dsl_text); plan->check_identical(*ref_plan); -} \ No newline at end of file +} + +TEST_P(PlanProtoTest, BinaryArithOpEvalRange) { + // xxx.query(predicates = "int64field > 3", topk = 10, ...) + auto data_type = std::get<0>(GetParam()); + auto data_type_str = spb::DataType_Name(data_type); + auto field_id = 100 + (int)data_type; + auto field_name = data_type_str + "Field"; + string value_tag = "bool_val"; + if (datatype_is_floating((DataType)data_type)) { + value_tag = "float_val"; + } else if (datatype_is_integer((DataType)data_type)) { + value_tag = "int64_val"; + } + + auto fmt1 = boost::format(R"( +vector_anns: < + field_id: 201 + predicates: < + binary_arith_op_eval_range_expr: < + column_info: < + field_id: %1% + data_type: %2% + > + arith_op: Add + right_operand: < + %3%: 1029 + > + op: Equal + value: < + %3%: 2016 + > + > + > + query_info: < + topk: 10 + round_decimal: 3 + metric_type: "L2" + search_params: "{\"nprobe\": 10}" + > + placeholder_tag: "$0" +> +)") % field_id % data_type_str % + value_tag; + + auto proto_text = fmt1.str(); + planpb::PlanNode node_proto; + google::protobuf::TextFormat::ParseFromString(proto_text, &node_proto); + // std::cout << node_proto.DebugString(); + auto plan = ProtoParser(*schema).CreatePlan(node_proto); + + ShowPlanNodeVisitor visitor; + auto json = visitor.call_child(*plan->plan_node_); + // std::cout << json.dump(2); + auto extra_info = plan->extra_info_opt_.value(); + + std::string dsl_text = boost::str(boost::format(R"( +{ + "bool": { + "must": [ + { + "range": { + "%1%": { + "EQ": { + "ADD": { + "right_operand": 1029, + "value": 2016 + } + } + } + } + }, + { + "vector": { + "FloatVectorField": { + "metric_type": "L2", + "params": { + "nprobe": 10 + }, + "query": "$0", + "topk": 10, + "round_decimal": 3 + } + } + } + ] + } +} +)") % field_name); + + auto ref_plan = CreatePlan(*schema, dsl_text); + plan->check_identical(*ref_plan); +} diff --git a/internal/core/unittest/test_utils/DataGen.h b/internal/core/unittest/test_utils/DataGen.h index 78093bfbcb..a7f4d65be8 100644 --- a/internal/core/unittest/test_utils/DataGen.h +++ b/internal/core/unittest/test_utils/DataGen.h @@ -168,6 +168,22 @@ DataGen(SchemaPtr schema, int64_t N, uint64_t seed = 42, uint64_t ts_offset = 0) insert_cols(data); break; } + case engine::DataType::INT16: { + vector data(N); + for (auto& x : data) { + x = er() % (2 * N); + } + insert_cols(data); + break; + } + case engine::DataType::INT8: { + vector data(N); + for (auto& x : data) { + x = er() % (2 * N); + } + insert_cols(data); + break; + } case engine::DataType::FLOAT: { vector data(N); for (auto& x : data) { diff --git a/internal/proto/plan.proto b/internal/proto/plan.proto index 9fa1ba6f05..1729b734cf 100644 --- a/internal/proto/plan.proto +++ b/internal/proto/plan.proto @@ -14,6 +14,15 @@ enum OpType { NotEqual = 6; }; +enum ArithOpType { + Unknown = 0; + Add = 1; + Sub = 2; + Mul = 3; + Div = 4; + Mod = 5; +}; + message GenericValue { oneof val { bool bool_val = 1; @@ -82,6 +91,20 @@ message BinaryExpr { Expr right = 3; } +message BinaryArithOp { + ColumnInfo column_info = 1; + ArithOpType arith_op = 2; + GenericValue right_operand = 3; +} + +message BinaryArithOpEvalRangeExpr { + ColumnInfo column_info = 1; + ArithOpType arith_op = 2; + GenericValue right_operand = 3; + OpType op = 4; + GenericValue value = 5; +} + message Expr { oneof expr { TermExpr term_expr = 1; @@ -90,6 +113,7 @@ message Expr { CompareExpr compare_expr = 4; UnaryRangeExpr unary_range_expr = 5; BinaryRangeExpr binary_range_expr = 6; + BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; }; } diff --git a/internal/proto/planpb/plan.pb.go b/internal/proto/planpb/plan.pb.go index 2be187bff9..89c48d61a7 100644 --- a/internal/proto/planpb/plan.pb.go +++ b/internal/proto/planpb/plan.pb.go @@ -61,6 +61,43 @@ func (OpType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_2d655ab2f7683c23, []int{0} } +type ArithOpType int32 + +const ( + ArithOpType_Unknown ArithOpType = 0 + ArithOpType_Add ArithOpType = 1 + ArithOpType_Sub ArithOpType = 2 + ArithOpType_Mul ArithOpType = 3 + ArithOpType_Div ArithOpType = 4 + ArithOpType_Mod ArithOpType = 5 +) + +var ArithOpType_name = map[int32]string{ + 0: "Unknown", + 1: "Add", + 2: "Sub", + 3: "Mul", + 4: "Div", + 5: "Mod", +} + +var ArithOpType_value = map[string]int32{ + "Unknown": 0, + "Add": 1, + "Sub": 2, + "Mul": 3, + "Div": 4, + "Mod": 5, +} + +func (x ArithOpType) String() string { + return proto.EnumName(ArithOpType_name, int32(x)) +} + +func (ArithOpType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_2d655ab2f7683c23, []int{1} +} + type UnaryExpr_UnaryOp int32 const ( @@ -680,6 +717,132 @@ func (m *BinaryExpr) GetRight() *Expr { return nil } +type BinaryArithOp struct { + ColumnInfo *ColumnInfo `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"` + ArithOp ArithOpType `protobuf:"varint,2,opt,name=arith_op,json=arithOp,proto3,enum=milvus.proto.plan.ArithOpType" json:"arith_op,omitempty"` + RightOperand *GenericValue `protobuf:"bytes,3,opt,name=right_operand,json=rightOperand,proto3" json:"right_operand,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BinaryArithOp) Reset() { *m = BinaryArithOp{} } +func (m *BinaryArithOp) String() string { return proto.CompactTextString(m) } +func (*BinaryArithOp) ProtoMessage() {} +func (*BinaryArithOp) Descriptor() ([]byte, []int) { + return fileDescriptor_2d655ab2f7683c23, []int{9} +} + +func (m *BinaryArithOp) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BinaryArithOp.Unmarshal(m, b) +} +func (m *BinaryArithOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BinaryArithOp.Marshal(b, m, deterministic) +} +func (m *BinaryArithOp) XXX_Merge(src proto.Message) { + xxx_messageInfo_BinaryArithOp.Merge(m, src) +} +func (m *BinaryArithOp) XXX_Size() int { + return xxx_messageInfo_BinaryArithOp.Size(m) +} +func (m *BinaryArithOp) XXX_DiscardUnknown() { + xxx_messageInfo_BinaryArithOp.DiscardUnknown(m) +} + +var xxx_messageInfo_BinaryArithOp proto.InternalMessageInfo + +func (m *BinaryArithOp) GetColumnInfo() *ColumnInfo { + if m != nil { + return m.ColumnInfo + } + return nil +} + +func (m *BinaryArithOp) GetArithOp() ArithOpType { + if m != nil { + return m.ArithOp + } + return ArithOpType_Unknown +} + +func (m *BinaryArithOp) GetRightOperand() *GenericValue { + if m != nil { + return m.RightOperand + } + return nil +} + +type BinaryArithOpEvalRangeExpr struct { + ColumnInfo *ColumnInfo `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"` + ArithOp ArithOpType `protobuf:"varint,2,opt,name=arith_op,json=arithOp,proto3,enum=milvus.proto.plan.ArithOpType" json:"arith_op,omitempty"` + RightOperand *GenericValue `protobuf:"bytes,3,opt,name=right_operand,json=rightOperand,proto3" json:"right_operand,omitempty"` + Op OpType `protobuf:"varint,4,opt,name=op,proto3,enum=milvus.proto.plan.OpType" json:"op,omitempty"` + Value *GenericValue `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BinaryArithOpEvalRangeExpr) Reset() { *m = BinaryArithOpEvalRangeExpr{} } +func (m *BinaryArithOpEvalRangeExpr) String() string { return proto.CompactTextString(m) } +func (*BinaryArithOpEvalRangeExpr) ProtoMessage() {} +func (*BinaryArithOpEvalRangeExpr) Descriptor() ([]byte, []int) { + return fileDescriptor_2d655ab2f7683c23, []int{10} +} + +func (m *BinaryArithOpEvalRangeExpr) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BinaryArithOpEvalRangeExpr.Unmarshal(m, b) +} +func (m *BinaryArithOpEvalRangeExpr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BinaryArithOpEvalRangeExpr.Marshal(b, m, deterministic) +} +func (m *BinaryArithOpEvalRangeExpr) XXX_Merge(src proto.Message) { + xxx_messageInfo_BinaryArithOpEvalRangeExpr.Merge(m, src) +} +func (m *BinaryArithOpEvalRangeExpr) XXX_Size() int { + return xxx_messageInfo_BinaryArithOpEvalRangeExpr.Size(m) +} +func (m *BinaryArithOpEvalRangeExpr) XXX_DiscardUnknown() { + xxx_messageInfo_BinaryArithOpEvalRangeExpr.DiscardUnknown(m) +} + +var xxx_messageInfo_BinaryArithOpEvalRangeExpr proto.InternalMessageInfo + +func (m *BinaryArithOpEvalRangeExpr) GetColumnInfo() *ColumnInfo { + if m != nil { + return m.ColumnInfo + } + return nil +} + +func (m *BinaryArithOpEvalRangeExpr) GetArithOp() ArithOpType { + if m != nil { + return m.ArithOp + } + return ArithOpType_Unknown +} + +func (m *BinaryArithOpEvalRangeExpr) GetRightOperand() *GenericValue { + if m != nil { + return m.RightOperand + } + return nil +} + +func (m *BinaryArithOpEvalRangeExpr) GetOp() OpType { + if m != nil { + return m.Op + } + return OpType_Invalid +} + +func (m *BinaryArithOpEvalRangeExpr) GetValue() *GenericValue { + if m != nil { + return m.Value + } + return nil +} + type Expr struct { // Types that are valid to be assigned to Expr: // *Expr_TermExpr @@ -688,6 +851,7 @@ type Expr struct { // *Expr_CompareExpr // *Expr_UnaryRangeExpr // *Expr_BinaryRangeExpr + // *Expr_BinaryArithOpEvalRangeExpr Expr isExpr_Expr `protobuf_oneof:"expr"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -698,7 +862,7 @@ func (m *Expr) Reset() { *m = Expr{} } func (m *Expr) String() string { return proto.CompactTextString(m) } func (*Expr) ProtoMessage() {} func (*Expr) Descriptor() ([]byte, []int) { - return fileDescriptor_2d655ab2f7683c23, []int{9} + return fileDescriptor_2d655ab2f7683c23, []int{11} } func (m *Expr) XXX_Unmarshal(b []byte) error { @@ -747,6 +911,10 @@ type Expr_BinaryRangeExpr struct { BinaryRangeExpr *BinaryRangeExpr `protobuf:"bytes,6,opt,name=binary_range_expr,json=binaryRangeExpr,proto3,oneof"` } +type Expr_BinaryArithOpEvalRangeExpr struct { + BinaryArithOpEvalRangeExpr *BinaryArithOpEvalRangeExpr `protobuf:"bytes,7,opt,name=binary_arith_op_eval_range_expr,json=binaryArithOpEvalRangeExpr,proto3,oneof"` +} + func (*Expr_TermExpr) isExpr_Expr() {} func (*Expr_UnaryExpr) isExpr_Expr() {} @@ -759,6 +927,8 @@ func (*Expr_UnaryRangeExpr) isExpr_Expr() {} func (*Expr_BinaryRangeExpr) isExpr_Expr() {} +func (*Expr_BinaryArithOpEvalRangeExpr) isExpr_Expr() {} + func (m *Expr) GetExpr() isExpr_Expr { if m != nil { return m.Expr @@ -808,6 +978,13 @@ func (m *Expr) GetBinaryRangeExpr() *BinaryRangeExpr { return nil } +func (m *Expr) GetBinaryArithOpEvalRangeExpr() *BinaryArithOpEvalRangeExpr { + if x, ok := m.GetExpr().(*Expr_BinaryArithOpEvalRangeExpr); ok { + return x.BinaryArithOpEvalRangeExpr + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Expr) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -817,6 +994,7 @@ func (*Expr) XXX_OneofWrappers() []interface{} { (*Expr_CompareExpr)(nil), (*Expr_UnaryRangeExpr)(nil), (*Expr_BinaryRangeExpr)(nil), + (*Expr_BinaryArithOpEvalRangeExpr)(nil), } } @@ -835,7 +1013,7 @@ func (m *VectorANNS) Reset() { *m = VectorANNS{} } func (m *VectorANNS) String() string { return proto.CompactTextString(m) } func (*VectorANNS) ProtoMessage() {} func (*VectorANNS) Descriptor() ([]byte, []int) { - return fileDescriptor_2d655ab2f7683c23, []int{10} + return fileDescriptor_2d655ab2f7683c23, []int{12} } func (m *VectorANNS) XXX_Unmarshal(b []byte) error { @@ -906,7 +1084,7 @@ func (m *PlanNode) Reset() { *m = PlanNode{} } func (m *PlanNode) String() string { return proto.CompactTextString(m) } func (*PlanNode) ProtoMessage() {} func (*PlanNode) Descriptor() ([]byte, []int) { - return fileDescriptor_2d655ab2f7683c23, []int{11} + return fileDescriptor_2d655ab2f7683c23, []int{13} } func (m *PlanNode) XXX_Unmarshal(b []byte) error { @@ -981,6 +1159,7 @@ func (*PlanNode) XXX_OneofWrappers() []interface{} { func init() { proto.RegisterEnum("milvus.proto.plan.OpType", OpType_name, OpType_value) + proto.RegisterEnum("milvus.proto.plan.ArithOpType", ArithOpType_name, ArithOpType_value) proto.RegisterEnum("milvus.proto.plan.UnaryExpr_UnaryOp", UnaryExpr_UnaryOp_name, UnaryExpr_UnaryOp_value) proto.RegisterEnum("milvus.proto.plan.BinaryExpr_BinaryOp", BinaryExpr_BinaryOp_name, BinaryExpr_BinaryOp_value) proto.RegisterType((*GenericValue)(nil), "milvus.proto.plan.GenericValue") @@ -992,6 +1171,8 @@ func init() { proto.RegisterType((*TermExpr)(nil), "milvus.proto.plan.TermExpr") proto.RegisterType((*UnaryExpr)(nil), "milvus.proto.plan.UnaryExpr") proto.RegisterType((*BinaryExpr)(nil), "milvus.proto.plan.BinaryExpr") + proto.RegisterType((*BinaryArithOp)(nil), "milvus.proto.plan.BinaryArithOp") + proto.RegisterType((*BinaryArithOpEvalRangeExpr)(nil), "milvus.proto.plan.BinaryArithOpEvalRangeExpr") proto.RegisterType((*Expr)(nil), "milvus.proto.plan.Expr") proto.RegisterType((*VectorANNS)(nil), "milvus.proto.plan.VectorANNS") proto.RegisterType((*PlanNode)(nil), "milvus.proto.plan.PlanNode") @@ -1000,75 +1181,84 @@ func init() { func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) } var fileDescriptor_2d655ab2f7683c23 = []byte{ - // 1108 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x72, 0x1b, 0xc5, - 0x13, 0xd7, 0x6a, 0x25, 0x79, 0xb7, 0xa5, 0x48, 0xf2, 0x5e, 0xfe, 0xce, 0xdf, 0x04, 0x9b, 0x25, - 0x45, 0x04, 0x54, 0xec, 0x22, 0x09, 0x4e, 0x11, 0x0a, 0xca, 0x5f, 0xc1, 0x52, 0x11, 0x6c, 0xb3, - 0x18, 0x1f, 0xb8, 0x6c, 0x8d, 0x76, 0xc7, 0xd2, 0x54, 0x56, 0x33, 0xeb, 0xd9, 0x59, 0x11, 0x9d, - 0xb9, 0x71, 0xe3, 0x25, 0xe0, 0x0c, 0x37, 0xde, 0x81, 0x07, 0xe0, 0xce, 0x8b, 0x50, 0xd3, 0xb3, - 0xd6, 0x47, 0x4a, 0x76, 0x4c, 0x55, 0x6e, 0x33, 0xbf, 0xe9, 0xee, 0xe9, 0x5f, 0x7f, 0xcd, 0x00, - 0xa4, 0x09, 0xe1, 0x5b, 0xa9, 0x14, 0x4a, 0x78, 0xab, 0x23, 0x96, 0x8c, 0xf3, 0xcc, 0xec, 0xb6, - 0xf4, 0xc1, 0xff, 0x1b, 0x59, 0x34, 0xa4, 0x23, 0x62, 0x20, 0xff, 0x17, 0x0b, 0x1a, 0x47, 0x94, - 0x53, 0xc9, 0xa2, 0x73, 0x92, 0xe4, 0xd4, 0x5b, 0x07, 0xa7, 0x2f, 0x44, 0x12, 0x8e, 0x49, 0xb2, - 0x66, 0x6d, 0x5a, 0x1d, 0xa7, 0x5b, 0x0a, 0x56, 0x34, 0x72, 0x4e, 0x12, 0xef, 0x1e, 0xb8, 0x8c, - 0xab, 0x9d, 0x27, 0x78, 0x5a, 0xde, 0xb4, 0x3a, 0x76, 0xb7, 0x14, 0x38, 0x08, 0x15, 0xc7, 0x17, - 0x89, 0x20, 0x0a, 0x8f, 0xed, 0x4d, 0xab, 0x63, 0xe9, 0x63, 0x84, 0xf4, 0xf1, 0x06, 0x40, 0xa6, - 0x24, 0xe3, 0x03, 0x3c, 0xaf, 0x6c, 0x5a, 0x1d, 0xb7, 0x5b, 0x0a, 0x5c, 0x83, 0x9d, 0x93, 0x64, - 0xbf, 0x0a, 0xf6, 0x98, 0x24, 0xfe, 0xcf, 0x16, 0xb8, 0xdf, 0xe6, 0x54, 0x4e, 0x7a, 0xfc, 0x42, - 0x78, 0x1e, 0x54, 0x94, 0x48, 0x5f, 0xa2, 0x33, 0x76, 0x80, 0x6b, 0x6f, 0x03, 0xea, 0x23, 0xaa, - 0x24, 0x8b, 0x42, 0x35, 0x49, 0x29, 0x5e, 0xe5, 0x06, 0x60, 0xa0, 0xb3, 0x49, 0x4a, 0xbd, 0xf7, - 0xe1, 0x4e, 0x46, 0x89, 0x8c, 0x86, 0x61, 0x4a, 0x24, 0x19, 0x65, 0xe6, 0xb6, 0xa0, 0x61, 0xc0, - 0x53, 0xc4, 0xb4, 0x90, 0x14, 0x39, 0x8f, 0xc3, 0x98, 0x46, 0x6c, 0x44, 0x92, 0xb5, 0x2a, 0x5e, - 0xd1, 0x40, 0xf0, 0xd0, 0x60, 0xfe, 0xaf, 0x16, 0xc0, 0x81, 0x48, 0xf2, 0x11, 0x47, 0x6f, 0xee, - 0x82, 0x73, 0xc1, 0x68, 0x12, 0x87, 0x2c, 0x2e, 0x3c, 0x5a, 0xc1, 0x7d, 0x2f, 0xf6, 0x9e, 0x81, - 0x1b, 0x13, 0x45, 0x8c, 0x4b, 0x3a, 0x38, 0xcd, 0x47, 0xf7, 0xb6, 0x16, 0xe2, 0x5f, 0x44, 0xfe, - 0x90, 0x28, 0xa2, 0xbd, 0x0c, 0x9c, 0xb8, 0x58, 0x79, 0xf7, 0xa1, 0xc9, 0xb2, 0x30, 0x95, 0x6c, - 0x44, 0xe4, 0x24, 0x7c, 0x49, 0x27, 0xc8, 0xc9, 0x09, 0x1a, 0x2c, 0x3b, 0x35, 0xe0, 0xd7, 0x74, - 0xe2, 0xad, 0x83, 0xcb, 0xb2, 0x90, 0xe4, 0x4a, 0xf4, 0x0e, 0x91, 0x91, 0x13, 0x38, 0x2c, 0xdb, - 0xc3, 0xbd, 0xff, 0x87, 0x05, 0xcd, 0xef, 0x39, 0x91, 0x93, 0x80, 0xf0, 0x01, 0x7d, 0xfe, 0x2a, - 0x95, 0xde, 0x97, 0x50, 0x8f, 0xd0, 0xf5, 0x90, 0xf1, 0x0b, 0x81, 0xfe, 0xd6, 0x5f, 0xf7, 0x09, - 0x8b, 0x65, 0x46, 0x30, 0x80, 0x68, 0x46, 0xf6, 0x43, 0x28, 0x8b, 0xb4, 0xa0, 0x72, 0x77, 0x89, - 0xda, 0x49, 0x8a, 0x34, 0xca, 0x22, 0xf5, 0x3e, 0x85, 0xea, 0x58, 0xd7, 0x0f, 0xfa, 0x5d, 0x7f, - 0xb4, 0xb1, 0x44, 0x7a, 0xbe, 0xcc, 0x02, 0x23, 0xed, 0xff, 0x56, 0x86, 0xd6, 0x3e, 0x7b, 0xbb, - 0x5e, 0x3f, 0x80, 0x56, 0x22, 0x7e, 0xa4, 0x32, 0x64, 0x3c, 0x4a, 0xf2, 0x8c, 0x8d, 0x4d, 0x36, - 0x9c, 0xa0, 0x89, 0x70, 0xef, 0x0a, 0xd5, 0x82, 0x79, 0x9a, 0x2e, 0x08, 0x9a, 0xa8, 0x37, 0x11, - 0x9e, 0x09, 0xee, 0x42, 0xdd, 0x58, 0x34, 0x14, 0x2b, 0xb7, 0xa3, 0x08, 0xa8, 0x63, 0xba, 0x6a, - 0x17, 0xea, 0xe6, 0x2a, 0x63, 0xa1, 0x7a, 0x4b, 0x0b, 0xa8, 0x83, 0x6b, 0xff, 0x2f, 0x0b, 0xea, - 0x07, 0x62, 0x94, 0x12, 0x69, 0xa2, 0x74, 0x04, 0xed, 0x84, 0x5e, 0xa8, 0xf0, 0x3f, 0x87, 0xaa, - 0xa9, 0xd5, 0xe6, 0x2a, 0xba, 0x07, 0xab, 0x92, 0x0d, 0x86, 0x8b, 0x96, 0xca, 0xb7, 0xb1, 0xd4, - 0x42, 0xbd, 0x83, 0xd7, 0xeb, 0xc5, 0xbe, 0x45, 0xbd, 0xf8, 0x3f, 0x59, 0xe0, 0x9c, 0x51, 0x39, - 0x7a, 0x2b, 0x19, 0x7f, 0x0a, 0x35, 0x8c, 0x6b, 0xb6, 0x56, 0xde, 0xb4, 0x6f, 0x13, 0xd8, 0x42, - 0x5c, 0x4f, 0x3f, 0x17, 0x7b, 0x06, 0xdd, 0x78, 0x82, 0xee, 0x5b, 0xe8, 0xfe, 0xfd, 0x25, 0x26, - 0xa6, 0x92, 0x66, 0x75, 0x92, 0x62, 0xe5, 0x3f, 0x84, 0x6a, 0x34, 0x64, 0x49, 0x5c, 0xc4, 0xec, - 0x7f, 0x4b, 0x14, 0xb5, 0x4e, 0x60, 0xa4, 0xfc, 0x0d, 0x58, 0x29, 0xb4, 0xbd, 0x3a, 0xac, 0xf4, - 0xf8, 0x98, 0x24, 0x2c, 0x6e, 0x97, 0xbc, 0x15, 0xb0, 0x8f, 0x85, 0x6a, 0x5b, 0xfe, 0xdf, 0x16, - 0x80, 0x69, 0x09, 0x74, 0x6a, 0x67, 0xce, 0xa9, 0x0f, 0x96, 0xd8, 0x9e, 0x89, 0x16, 0xcb, 0xc2, - 0xad, 0x8f, 0xa1, 0xa2, 0x13, 0xfd, 0x26, 0xaf, 0x50, 0x48, 0x73, 0xc0, 0x5c, 0x16, 0xdd, 0x7b, - 0x3d, 0x07, 0x94, 0xf2, 0x77, 0xc0, 0xb9, 0xba, 0x6b, 0x91, 0x44, 0x13, 0xe0, 0x85, 0x18, 0xb0, - 0x88, 0x24, 0x7b, 0x3c, 0x6e, 0x5b, 0xde, 0x1d, 0x70, 0x8b, 0xfd, 0x89, 0x6c, 0x97, 0xfd, 0xdf, - 0x6d, 0xa8, 0x20, 0xa9, 0x67, 0xe0, 0x2a, 0x2a, 0x47, 0x21, 0x7d, 0x95, 0xca, 0x22, 0xdd, 0xeb, - 0x4b, 0xee, 0xbc, 0x2a, 0x10, 0xfd, 0x8a, 0xa8, 0xab, 0x62, 0xf9, 0x02, 0x20, 0xd7, 0x77, 0x1b, - 0x65, 0x43, 0xef, 0x9d, 0x9b, 0xb2, 0xa5, 0xdf, 0x98, 0x7c, 0x1a, 0xcf, 0x5d, 0xa8, 0xf7, 0xd9, - 0x4c, 0xdf, 0xbe, 0xb6, 0xd6, 0x66, 0x81, 0xed, 0x96, 0x02, 0xe8, 0xcf, 0x32, 0x72, 0x00, 0x8d, - 0xc8, 0x34, 0xa2, 0x31, 0x61, 0xc6, 0xc1, 0xbb, 0x4b, 0xcb, 0x75, 0xda, 0xaf, 0xdd, 0x52, 0x50, - 0x8f, 0xe6, 0xda, 0xf7, 0x1b, 0x68, 0x1b, 0x16, 0x52, 0xcf, 0x3d, 0x63, 0xc8, 0x4c, 0x85, 0xf7, - 0xae, 0xe3, 0x32, 0x9d, 0x90, 0xdd, 0x52, 0xd0, 0xcc, 0x17, 0x67, 0xe6, 0x29, 0xac, 0x16, 0xac, - 0xe6, 0xec, 0xd5, 0xd0, 0x9e, 0x7f, 0x2d, 0xb7, 0x79, 0x83, 0xad, 0xfe, 0x22, 0xb4, 0x5f, 0x83, - 0x8a, 0x36, 0xe2, 0xff, 0x63, 0x01, 0x9c, 0xd3, 0x48, 0x09, 0xb9, 0x77, 0x7c, 0xfc, 0x5d, 0xf1, - 0x04, 0x19, 0x61, 0xf3, 0x3f, 0xd0, 0x4f, 0x90, 0xb1, 0xb7, 0xf0, 0x38, 0x96, 0x17, 0x1f, 0xc7, - 0xa7, 0x00, 0xa9, 0xa4, 0x31, 0x8b, 0x88, 0xa2, 0xd9, 0x9b, 0xca, 0x6c, 0x4e, 0xd4, 0xfb, 0x1c, - 0xe0, 0x52, 0xff, 0x05, 0xcc, 0x68, 0xa8, 0x5c, 0x9b, 0xee, 0xe9, 0x87, 0x21, 0x70, 0x2f, 0xa7, - 0x7f, 0x87, 0x07, 0xd0, 0x4a, 0x13, 0x12, 0xd1, 0xa1, 0x48, 0x62, 0x2a, 0x43, 0x45, 0x06, 0x18, - 0x64, 0x37, 0x68, 0xce, 0xc1, 0x67, 0x64, 0xe0, 0xff, 0x69, 0x81, 0x73, 0x9a, 0x10, 0x7e, 0x2c, - 0x62, 0x1c, 0xd6, 0x63, 0x64, 0x1c, 0x12, 0xce, 0xb3, 0x1b, 0xc6, 0xd1, 0x2c, 0x2e, 0xba, 0x44, - 0x8c, 0xce, 0x1e, 0xe7, 0x99, 0xf7, 0xd9, 0x02, 0xdb, 0x9b, 0x5b, 0x50, 0xab, 0xce, 0xf1, 0xed, - 0x40, 0x5b, 0xe4, 0x2a, 0xcd, 0x55, 0x78, 0x15, 0x4a, 0x1d, 0x2e, 0xbb, 0x63, 0x07, 0x4d, 0x83, - 0x7f, 0x65, 0x22, 0x9a, 0xe9, 0x0c, 0x71, 0x11, 0xd3, 0x8f, 0x38, 0xd4, 0xcc, 0x60, 0x5d, 0xec, - 0xc5, 0x16, 0xd4, 0x8f, 0x24, 0x25, 0x8a, 0xca, 0xb3, 0x21, 0xe1, 0x6d, 0xcb, 0x6b, 0x43, 0xa3, - 0x00, 0x9e, 0x5f, 0xe6, 0x24, 0x69, 0x97, 0xbd, 0x06, 0x38, 0x2f, 0x68, 0x96, 0xe1, 0xb9, 0x8d, - 0xcd, 0x4a, 0xb3, 0xcc, 0x1c, 0x56, 0x3c, 0x17, 0xaa, 0x66, 0x59, 0xd5, 0x72, 0xc7, 0x42, 0x99, - 0x5d, 0x6d, 0xff, 0xf1, 0x0f, 0x9f, 0x0c, 0x98, 0x1a, 0xe6, 0xfd, 0xad, 0x48, 0x8c, 0xb6, 0x0d, - 0xa9, 0x87, 0x4c, 0x14, 0xab, 0x6d, 0xc6, 0x15, 0x95, 0x9c, 0x24, 0xdb, 0xc8, 0x73, 0x5b, 0xf3, - 0x4c, 0xfb, 0xfd, 0x1a, 0xee, 0x1e, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xeb, 0xf1, 0x90, 0xdc, - 0x9d, 0x0a, 0x00, 0x00, + // 1262 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0x4b, 0x73, 0x13, 0xc7, + 0x13, 0xd7, 0x6a, 0x25, 0x6b, 0xb7, 0x25, 0xcb, 0xcb, 0x5e, 0xfe, 0x3c, 0xfe, 0x60, 0x67, 0x43, + 0x05, 0x87, 0x14, 0x76, 0x05, 0x08, 0x14, 0xa4, 0x92, 0xc2, 0x0f, 0x62, 0xb9, 0x02, 0xb6, 0xb3, + 0x18, 0x1f, 0x72, 0xd9, 0x1a, 0xed, 0x8e, 0xa5, 0x29, 0x46, 0x33, 0xcb, 0xec, 0xae, 0x40, 0xe7, + 0xdc, 0x72, 0xcb, 0x97, 0x48, 0xee, 0xb9, 0xe5, 0x94, 0x2f, 0x90, 0x43, 0x8e, 0xb9, 0xe7, 0x8b, + 0xa4, 0xa6, 0x67, 0xad, 0x07, 0x25, 0x81, 0xa9, 0x50, 0x95, 0xdb, 0x4c, 0x4f, 0x77, 0x4f, 0xff, + 0xfa, 0x0d, 0x90, 0x72, 0x22, 0x36, 0x52, 0x25, 0x73, 0xe9, 0x5f, 0x18, 0x30, 0x3e, 0x2c, 0x32, + 0x73, 0xdb, 0xd0, 0x0f, 0x97, 0x5b, 0x59, 0xdc, 0xa7, 0x03, 0x62, 0x48, 0xc1, 0x4f, 0x16, 0xb4, + 0xf6, 0xa8, 0xa0, 0x8a, 0xc5, 0x27, 0x84, 0x17, 0xd4, 0xbf, 0x02, 0x4e, 0x57, 0x4a, 0x1e, 0x0d, + 0x09, 0xbf, 0x68, 0xad, 0x59, 0xeb, 0x4e, 0xa7, 0x12, 0x36, 0x34, 0xe5, 0x84, 0x70, 0xff, 0x2a, + 0xb8, 0x4c, 0xe4, 0xf7, 0xee, 0xe2, 0x6b, 0x75, 0xcd, 0x5a, 0xb7, 0x3b, 0x95, 0xd0, 0x41, 0x52, + 0xf9, 0x7c, 0xca, 0x25, 0xc9, 0xf1, 0xd9, 0x5e, 0xb3, 0xd6, 0x2d, 0xfd, 0x8c, 0x24, 0xfd, 0xbc, + 0x0a, 0x90, 0xe5, 0x8a, 0x89, 0x1e, 0xbe, 0xd7, 0xd6, 0xac, 0x75, 0xb7, 0x53, 0x09, 0x5d, 0x43, + 0x3b, 0x21, 0x7c, 0xbb, 0x0e, 0xf6, 0x90, 0xf0, 0xe0, 0x47, 0x0b, 0xdc, 0xef, 0x0a, 0xaa, 0x46, + 0xfb, 0xe2, 0x54, 0xfa, 0x3e, 0xd4, 0x72, 0x99, 0xbe, 0x40, 0x63, 0xec, 0x10, 0xcf, 0xfe, 0x2a, + 0x34, 0x07, 0x34, 0x57, 0x2c, 0x8e, 0xf2, 0x51, 0x4a, 0xf1, 0x2b, 0x37, 0x04, 0x43, 0x3a, 0x1e, + 0xa5, 0xd4, 0xff, 0x18, 0x96, 0x33, 0x4a, 0x54, 0xdc, 0x8f, 0x52, 0xa2, 0xc8, 0x20, 0x33, 0xbf, + 0x85, 0x2d, 0x43, 0x3c, 0x42, 0x9a, 0x66, 0x52, 0xb2, 0x10, 0x49, 0x94, 0xd0, 0x98, 0x0d, 0x08, + 0xbf, 0x58, 0xc7, 0x2f, 0x5a, 0x48, 0xdc, 0x35, 0xb4, 0xe0, 0x67, 0x0b, 0x60, 0x47, 0xf2, 0x62, + 0x20, 0xd0, 0x9a, 0x4b, 0xe0, 0x9c, 0x32, 0xca, 0x93, 0x88, 0x25, 0xa5, 0x45, 0x0d, 0xbc, 0xef, + 0x27, 0xfe, 0x43, 0x70, 0x13, 0x92, 0x13, 0x63, 0x92, 0x76, 0x4e, 0xfb, 0xf6, 0xd5, 0x8d, 0x19, + 0xff, 0x97, 0x9e, 0xdf, 0x25, 0x39, 0xd1, 0x56, 0x86, 0x4e, 0x52, 0x9e, 0xfc, 0xeb, 0xd0, 0x66, + 0x59, 0x94, 0x2a, 0x36, 0x20, 0x6a, 0x14, 0xbd, 0xa0, 0x23, 0xc4, 0xe4, 0x84, 0x2d, 0x96, 0x1d, + 0x19, 0xe2, 0xb7, 0x74, 0xe4, 0x5f, 0x01, 0x97, 0x65, 0x11, 0x29, 0x72, 0xb9, 0xbf, 0x8b, 0x88, + 0x9c, 0xd0, 0x61, 0xd9, 0x16, 0xde, 0x83, 0x5f, 0x2d, 0x68, 0x3f, 0x17, 0x44, 0x8d, 0x42, 0x22, + 0x7a, 0xf4, 0xf1, 0xeb, 0x54, 0xf9, 0x5f, 0x43, 0x33, 0x46, 0xd3, 0x23, 0x26, 0x4e, 0x25, 0xda, + 0xdb, 0x7c, 0xd3, 0x26, 0x4c, 0x96, 0x09, 0xc0, 0x10, 0xe2, 0x09, 0xd8, 0x4f, 0xa1, 0x2a, 0xd3, + 0x12, 0xca, 0xa5, 0x39, 0x62, 0x87, 0x29, 0xc2, 0xa8, 0xca, 0xd4, 0xff, 0x02, 0xea, 0x43, 0x9d, + 0x3f, 0x68, 0x77, 0xf3, 0xf6, 0xea, 0x1c, 0xee, 0xe9, 0x34, 0x0b, 0x0d, 0x77, 0xf0, 0x4b, 0x15, + 0x56, 0xb6, 0xd9, 0x87, 0xb5, 0xfa, 0x06, 0xac, 0x70, 0xf9, 0x8a, 0xaa, 0x88, 0x89, 0x98, 0x17, + 0x19, 0x1b, 0x9a, 0x68, 0x38, 0x61, 0x1b, 0xc9, 0xfb, 0x67, 0x54, 0xcd, 0x58, 0xa4, 0xe9, 0x0c, + 0xa3, 0xf1, 0x7a, 0x1b, 0xc9, 0x13, 0xc6, 0x47, 0xd0, 0x34, 0x1a, 0x0d, 0xc4, 0xda, 0xf9, 0x20, + 0x02, 0xca, 0x98, 0xaa, 0x7a, 0x04, 0x4d, 0xf3, 0x95, 0xd1, 0x50, 0x3f, 0xa7, 0x06, 0x94, 0xc1, + 0x73, 0xf0, 0x87, 0x05, 0xcd, 0x1d, 0x39, 0x48, 0x89, 0x32, 0x5e, 0xda, 0x03, 0x8f, 0xd3, 0xd3, + 0x3c, 0x7a, 0x6f, 0x57, 0xb5, 0xb5, 0xd8, 0x54, 0x46, 0xef, 0xc3, 0x05, 0xc5, 0x7a, 0xfd, 0x59, + 0x4d, 0xd5, 0xf3, 0x68, 0x5a, 0x41, 0xb9, 0x9d, 0x37, 0xf3, 0xc5, 0x3e, 0x47, 0xbe, 0x04, 0x3f, + 0x58, 0xe0, 0x1c, 0x53, 0x35, 0xf8, 0x20, 0x11, 0xbf, 0x0f, 0x4b, 0xe8, 0xd7, 0xec, 0x62, 0x75, + 0xcd, 0x3e, 0x8f, 0x63, 0x4b, 0x76, 0xdd, 0xfd, 0x5c, 0xac, 0x19, 0x34, 0xe3, 0x2e, 0x9a, 0x6f, + 0xa1, 0xf9, 0xd7, 0xe7, 0xa8, 0x18, 0x73, 0x9a, 0xd3, 0x61, 0x8a, 0x99, 0x7f, 0x0b, 0xea, 0x71, + 0x9f, 0xf1, 0xa4, 0xf4, 0xd9, 0xff, 0xe6, 0x08, 0x6a, 0x99, 0xd0, 0x70, 0x05, 0xab, 0xd0, 0x28, + 0xa5, 0xfd, 0x26, 0x34, 0xf6, 0xc5, 0x90, 0x70, 0x96, 0x78, 0x15, 0xbf, 0x01, 0xf6, 0x81, 0xcc, + 0x3d, 0x2b, 0xf8, 0xcb, 0x02, 0x30, 0x25, 0x81, 0x46, 0xdd, 0x9b, 0x32, 0xea, 0x93, 0x39, 0xba, + 0x27, 0xac, 0xe5, 0xb1, 0x34, 0xeb, 0x33, 0xa8, 0xe9, 0x40, 0xbf, 0xcb, 0x2a, 0x64, 0xd2, 0x18, + 0x30, 0x96, 0x65, 0xf5, 0x2e, 0xc6, 0x80, 0x5c, 0xc1, 0x3d, 0x70, 0xce, 0xfe, 0x9a, 0x05, 0xd1, + 0x06, 0x78, 0x22, 0x7b, 0x2c, 0x26, 0x7c, 0x4b, 0x24, 0x9e, 0xe5, 0x2f, 0x83, 0x5b, 0xde, 0x0f, + 0x95, 0x57, 0x0d, 0xfe, 0xb4, 0x60, 0xd9, 0x08, 0x6e, 0x29, 0x96, 0xf7, 0x0f, 0xd3, 0x7f, 0x1d, + 0xf9, 0x07, 0xe0, 0x10, 0xad, 0x2a, 0x1a, 0xf7, 0xa9, 0x6b, 0x73, 0x84, 0xcb, 0xdf, 0x30, 0xf9, + 0x1a, 0xa4, 0xfc, 0x7a, 0x17, 0x96, 0x4d, 0xde, 0xcb, 0x94, 0x2a, 0x22, 0x92, 0xf3, 0x76, 0xae, + 0x16, 0x4a, 0x1d, 0x1a, 0xa1, 0xe0, 0xf7, 0x2a, 0x5c, 0x9e, 0x81, 0xf4, 0x78, 0x48, 0xf8, 0x87, + 0xeb, 0x65, 0xff, 0x35, 0xbe, 0xb2, 0xa4, 0x6b, 0xef, 0x35, 0x02, 0xea, 0xef, 0x37, 0x02, 0x6a, + 0x50, 0x43, 0x5f, 0x3d, 0x04, 0x37, 0xa7, 0x6a, 0x10, 0xd1, 0xd7, 0xa9, 0x2a, 0x3d, 0x75, 0x65, + 0x8e, 0x8e, 0xb3, 0xae, 0xa1, 0x57, 0x8b, 0xfc, 0xac, 0x83, 0x7c, 0x05, 0x50, 0xe8, 0x20, 0x18, + 0x61, 0x93, 0xf3, 0xff, 0x7f, 0x5b, 0x09, 0xeb, 0xc5, 0xa3, 0x18, 0x17, 0xd9, 0x23, 0x68, 0x76, + 0xd9, 0x44, 0xde, 0x5e, 0x18, 0xa6, 0x49, 0xb5, 0x75, 0x2a, 0x21, 0x74, 0x27, 0x65, 0xba, 0x03, + 0xad, 0xd8, 0x74, 0x67, 0xa3, 0xc2, 0xcc, 0x88, 0x6b, 0x73, 0x23, 0x3d, 0x6e, 0xe2, 0x9d, 0x4a, + 0xd8, 0x8c, 0xa7, 0x7a, 0xfa, 0x53, 0xf0, 0x0c, 0x0a, 0xa5, 0x13, 0xc8, 0x28, 0x32, 0xce, 0xfc, + 0x68, 0x11, 0x96, 0x71, 0xaa, 0x75, 0x2a, 0x61, 0xbb, 0x98, 0x1d, 0xa4, 0x47, 0x70, 0xa1, 0x44, + 0x35, 0xa5, 0x6f, 0x09, 0xf5, 0x05, 0x0b, 0xb1, 0x4d, 0x2b, 0x5c, 0xe9, 0xbe, 0x31, 0x9a, 0x73, + 0x58, 0x2d, 0x35, 0x9e, 0x65, 0x65, 0x44, 0x87, 0x84, 0x4f, 0xeb, 0x6f, 0xa0, 0xfe, 0x5b, 0x0b, + 0xf5, 0xcf, 0x2b, 0x93, 0x4e, 0x25, 0xbc, 0xdc, 0x5d, 0xf8, 0xba, 0xbd, 0x04, 0x35, 0xad, 0x3a, + 0xf8, 0xdb, 0x02, 0x38, 0xa1, 0x71, 0x2e, 0xd5, 0xd6, 0xc1, 0xc1, 0xb3, 0x72, 0x1b, 0x32, 0x72, + 0x66, 0x55, 0xd5, 0xdb, 0x90, 0xf9, 0x65, 0x66, 0x4f, 0xab, 0xce, 0xee, 0x69, 0xf7, 0x01, 0x52, + 0x45, 0x13, 0x16, 0x93, 0x9c, 0x66, 0xef, 0xea, 0x78, 0x53, 0xac, 0xfe, 0x97, 0x00, 0x2f, 0xf5, + 0x5a, 0x6a, 0x6a, 0xb9, 0xb6, 0x30, 0xc9, 0xc6, 0xbb, 0x6b, 0xe8, 0xbe, 0x1c, 0xaf, 0xb1, 0x37, + 0x60, 0x25, 0xe5, 0x24, 0xa6, 0x7d, 0xc9, 0x13, 0xaa, 0xa2, 0x9c, 0xf4, 0x30, 0xb4, 0x6e, 0xd8, + 0x9e, 0x22, 0x1f, 0x93, 0x5e, 0xf0, 0x9b, 0x05, 0xce, 0x11, 0x27, 0xe2, 0x40, 0x26, 0xb8, 0x37, + 0x0c, 0x11, 0x71, 0x44, 0x84, 0xc8, 0xde, 0xd2, 0x3f, 0x26, 0x7e, 0xd1, 0x89, 0x69, 0x64, 0xb6, + 0x84, 0xc8, 0xfc, 0x07, 0x33, 0x68, 0xdf, 0x3e, 0x0d, 0xb4, 0xe8, 0x14, 0xde, 0x75, 0xf0, 0x64, + 0x91, 0xa7, 0x45, 0x1e, 0x9d, 0xb9, 0x52, 0xbb, 0xcb, 0x5e, 0xb7, 0xc3, 0xb6, 0xa1, 0x7f, 0x63, + 0x3c, 0x9a, 0xe9, 0x08, 0x09, 0x99, 0xd0, 0x9b, 0x02, 0x96, 0x4c, 0x43, 0x98, 0x1d, 0x0b, 0x2b, + 0xd0, 0xdc, 0x53, 0x94, 0xe4, 0x54, 0x1d, 0xf7, 0x89, 0xf0, 0x2c, 0xdf, 0x83, 0x56, 0x49, 0x78, + 0xfc, 0xb2, 0x20, 0xdc, 0xab, 0xfa, 0x2d, 0x70, 0x9e, 0xd0, 0x2c, 0xc3, 0x77, 0x1b, 0xe7, 0x06, + 0xcd, 0x32, 0xf3, 0x58, 0xf3, 0x5d, 0xa8, 0x9b, 0x63, 0x5d, 0xf3, 0x1d, 0xc8, 0xdc, 0xdc, 0x96, + 0x6e, 0xee, 0x41, 0x73, 0xaa, 0xf7, 0xe9, 0x4f, 0x9f, 0x8b, 0x17, 0x42, 0xbe, 0x12, 0x66, 0xa0, + 0x6e, 0x25, 0x7a, 0x08, 0x35, 0xc0, 0x7e, 0x56, 0x74, 0xbd, 0xaa, 0x3e, 0x3c, 0x2d, 0xb8, 0x67, + 0xeb, 0xc3, 0x2e, 0x1b, 0x7a, 0x35, 0xa4, 0xc8, 0xc4, 0xab, 0x6f, 0xdf, 0xf9, 0xfe, 0xf3, 0x1e, + 0xcb, 0xfb, 0x45, 0x77, 0x23, 0x96, 0x83, 0x4d, 0xe3, 0x9d, 0x5b, 0x4c, 0x96, 0xa7, 0x4d, 0x26, + 0x72, 0xaa, 0x04, 0xe1, 0x9b, 0xe8, 0xb0, 0x4d, 0xed, 0xb0, 0xb4, 0xdb, 0x5d, 0xc2, 0xdb, 0x9d, + 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x95, 0x5c, 0x14, 0x9a, 0x71, 0x0d, 0x00, 0x00, } diff --git a/internal/proxy/plan_parser.go b/internal/proxy/plan_parser.go index 582c941340..26a775b0a6 100644 --- a/internal/proxy/plan_parser.go +++ b/internal/proxy/plan_parser.go @@ -72,8 +72,17 @@ func (optimizer *optimizer) Exit(node *ant_ast.Node) { floatNodeRight, rightFloat := node.Right.(*ant_ast.FloatNode) integerNodeRight, rightInteger := node.Right.(*ant_ast.IntegerNode) + // Check IdentifierNodes + identifierNodeLeft, leftIdentifier := node.Left.(*ant_ast.IdentifierNode) + identifierNodeRight, rightIdentifier := node.Right.(*ant_ast.IdentifierNode) + switch node.Operator { case "+": + funcName, err := getFuncNameByNodeOp(node.Operator) + if err != nil { + optimizer.err = err + return + } if leftFloat && rightFloat { patch(&ant_ast.FloatNode{Value: floatNodeLeft.Value + floatNodeRight.Value}) } else if leftFloat && rightInteger { @@ -82,11 +91,24 @@ func (optimizer *optimizer) Exit(node *ant_ast.Node) { patch(&ant_ast.FloatNode{Value: float64(integerNodeLeft.Value) + floatNodeRight.Value}) } else if leftInteger && rightInteger { patch(&ant_ast.IntegerNode{Value: integerNodeLeft.Value + integerNodeRight.Value}) + } else if leftIdentifier && rightFloat { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, floatNodeRight}}) + } else if leftIdentifier && rightInteger { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, integerNodeRight}}) + } else if leftFloat && rightIdentifier { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeRight, floatNodeLeft}}) + } else if leftInteger && rightIdentifier { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeRight, integerNodeLeft}}) } else { optimizer.err = fmt.Errorf("invalid data type") return } case "-": + funcName, err := getFuncNameByNodeOp(node.Operator) + if err != nil { + optimizer.err = err + return + } if leftFloat && rightFloat { patch(&ant_ast.FloatNode{Value: floatNodeLeft.Value - floatNodeRight.Value}) } else if leftFloat && rightInteger { @@ -95,11 +117,26 @@ func (optimizer *optimizer) Exit(node *ant_ast.Node) { patch(&ant_ast.FloatNode{Value: float64(integerNodeLeft.Value) - floatNodeRight.Value}) } else if leftInteger && rightInteger { patch(&ant_ast.IntegerNode{Value: integerNodeLeft.Value - integerNodeRight.Value}) + } else if leftIdentifier && rightFloat { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, floatNodeRight}}) + } else if leftIdentifier && rightInteger { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, integerNodeRight}}) + } else if leftFloat && rightIdentifier { + optimizer.err = fmt.Errorf("field as right operand is not yet supported for (%s) operator", node.Operator) + return + } else if leftInteger && rightIdentifier { + optimizer.err = fmt.Errorf("field as right operand is not yet supported for (%s) operator", node.Operator) + return } else { optimizer.err = fmt.Errorf("invalid data type") return } case "*": + funcName, err := getFuncNameByNodeOp(node.Operator) + if err != nil { + optimizer.err = err + return + } if leftFloat && rightFloat { patch(&ant_ast.FloatNode{Value: floatNodeLeft.Value * floatNodeRight.Value}) } else if leftFloat && rightInteger { @@ -108,11 +145,24 @@ func (optimizer *optimizer) Exit(node *ant_ast.Node) { patch(&ant_ast.FloatNode{Value: float64(integerNodeLeft.Value) * floatNodeRight.Value}) } else if leftInteger && rightInteger { patch(&ant_ast.IntegerNode{Value: integerNodeLeft.Value * integerNodeRight.Value}) + } else if leftIdentifier && rightFloat { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, floatNodeRight}}) + } else if leftIdentifier && rightInteger { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, integerNodeRight}}) + } else if leftFloat && rightIdentifier { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeRight, floatNodeLeft}}) + } else if leftInteger && rightIdentifier { + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeRight, integerNodeLeft}}) } else { optimizer.err = fmt.Errorf("invalid data type") return } case "/": + funcName, err := getFuncNameByNodeOp(node.Operator) + if err != nil { + optimizer.err = err + return + } if leftFloat && rightFloat { if floatNodeRight.Value == 0 { optimizer.err = fmt.Errorf("divide by zero") @@ -137,17 +187,49 @@ func (optimizer *optimizer) Exit(node *ant_ast.Node) { return } patch(&ant_ast.IntegerNode{Value: integerNodeLeft.Value / integerNodeRight.Value}) + } else if leftIdentifier && rightFloat { + if floatNodeRight.Value == 0 { + optimizer.err = fmt.Errorf("divide by zero") + return + } + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, floatNodeRight}}) + } else if leftIdentifier && rightInteger { + if integerNodeRight.Value == 0 { + optimizer.err = fmt.Errorf("divide by zero") + return + } + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, integerNodeRight}}) + } else if leftFloat && rightIdentifier { + optimizer.err = fmt.Errorf("field as right operand is not yet supported for (%s) operator", node.Operator) + return + } else if leftInteger && rightIdentifier { + optimizer.err = fmt.Errorf("field as right operand is not yet supported for (%s) operator", node.Operator) + return } else { optimizer.err = fmt.Errorf("invalid data type") return } case "%": + funcName, err := getFuncNameByNodeOp(node.Operator) + if err != nil { + optimizer.err = err + return + } if leftInteger && rightInteger { if integerNodeRight.Value == 0 { optimizer.err = fmt.Errorf("modulo by zero") return } patch(&ant_ast.IntegerNode{Value: integerNodeLeft.Value % integerNodeRight.Value}) + } else if leftIdentifier && rightInteger { + if integerNodeRight.Value == 0 { + optimizer.err = fmt.Errorf("modulo by zero") + return + } + patch(&ant_ast.FunctionNode{Name: funcName, Arguments: []ant_ast.Node{identifierNodeLeft, integerNodeRight}}) + } else if leftInteger && rightIdentifier { + optimizer.err = fmt.Errorf("field as right operand is not yet supported for (%s) operator", node.Operator) + return } else { optimizer.err = fmt.Errorf("invalid data type") return @@ -254,6 +336,46 @@ func getLogicalOpType(opStr string) planpb.BinaryExpr_BinaryOp { } } +func getArithOpType(funcName string) (planpb.ArithOpType, error) { + var op planpb.ArithOpType + + switch funcName { + case "add": + op = planpb.ArithOpType_Add + case "sub": + op = planpb.ArithOpType_Sub + case "mul": + op = planpb.ArithOpType_Mul + case "div": + op = planpb.ArithOpType_Div + case "mod": + op = planpb.ArithOpType_Mod + default: + return op, fmt.Errorf("unsupported or invalid arith op type: %s", funcName) + } + return op, nil +} + +func getFuncNameByNodeOp(nodeOp string) (string, error) { + var funcName string + + switch nodeOp { + case "+": + funcName = "add" + case "-": + funcName = "sub" + case "*": + funcName = "mul" + case "/": + funcName = "div" + case "%": + funcName = "mod" + default: + return funcName, fmt.Errorf("no defined funcName assigned to nodeOp: %s", nodeOp) + } + return funcName, nil +} + func parseBoolNode(nodeRaw *ant_ast.Node) *ant_ast.BoolNode { switch node := (*nodeRaw).(type) { case *ant_ast.IdentifierNode: @@ -352,10 +474,54 @@ func (pc *parserContext) createCmpExpr(left, right ant_ast.Node, operator string return expr, nil } +func (pc *parserContext) createBinaryArithOpEvalExpr(left *ant_ast.FunctionNode, right *ant_ast.Node, operator string) (*planpb.Expr, error) { + switch operator { + case "==", "!=": + binArithOp, err := pc.handleFunction(left) + if err != nil { + return nil, fmt.Errorf("createBinaryArithOpEvalExpr: %v", err) + } + op := getCompareOpType(operator, false) + val, err := pc.handleLeafValue(right, binArithOp.ColumnInfo.DataType) + if err != nil { + return nil, err + } + + expr := &planpb.Expr{ + Expr: &planpb.Expr_BinaryArithOpEvalRangeExpr{ + BinaryArithOpEvalRangeExpr: &planpb.BinaryArithOpEvalRangeExpr{ + ColumnInfo: binArithOp.ColumnInfo, + ArithOp: binArithOp.ArithOp, + RightOperand: binArithOp.RightOperand, + Op: op, + Value: val, + }, + }, + } + return expr, nil + } + return nil, fmt.Errorf("operator(%s) not yet supported for function nodes", operator) +} + func (pc *parserContext) handleCmpExpr(node *ant_ast.BinaryNode) (*planpb.Expr, error) { return pc.createCmpExpr(node.Left, node.Right, node.Operator) } +func (pc *parserContext) handleBinaryArithCmpExpr(node *ant_ast.BinaryNode) (*planpb.Expr, error) { + leftNode, funcNodeLeft := node.Left.(*ant_ast.FunctionNode) + _, funcNodeRight := node.Right.(*ant_ast.FunctionNode) + + if funcNodeRight { + return nil, fmt.Errorf("right node as a function is not supported yet") + } else if !funcNodeLeft { + // Both left and right are not function nodes, pass to createCmpExpr + return pc.createCmpExpr(node.Left, node.Right, node.Operator) + } else { + // Only the left node is a function node + return pc.createBinaryArithOpEvalExpr(leftNode, &node.Right, node.Operator) + } +} + func (pc *parserContext) handleLogicalExpr(node *ant_ast.BinaryNode) (*planpb.Expr, error) { op := getLogicalOpType(node.Operator) if op == planpb.BinaryExpr_Invalid { @@ -517,6 +683,12 @@ func (pc *parserContext) handleMultiCmpExpr(node *ant_ast.BinaryNode) (*planpb.E } func (pc *parserContext) handleBinaryExpr(node *ant_ast.BinaryNode) (*planpb.Expr, error) { + _, arithExpr := node.Left.(*ant_ast.FunctionNode) + + if arithExpr { + return pc.handleBinaryArithCmpExpr(node) + } + switch node.Operator { case "<", "<=", ">", ">=": return pc.handleMultiCmpExpr(node) @@ -597,6 +769,37 @@ func (pc *parserContext) handleLeafValue(nodeRaw *ant_ast.Node, dataType schemap return gv, nil } +func (pc *parserContext) handleFunction(node *ant_ast.FunctionNode) (*planpb.BinaryArithOp, error) { + funcArithOp, err := getArithOpType(node.Name) + if err != nil { + return nil, err + } + + idNode, ok := node.Arguments[0].(*ant_ast.IdentifierNode) + if !ok { + return nil, fmt.Errorf("left operand of the function must be an identifier") + } + + field, err := pc.handleIdentifier(idNode) + if err != nil { + return nil, err + } + + valueNode := node.Arguments[1] + val, err := pc.handleLeafValue(&valueNode, field.DataType) + if err != nil { + return nil, err + } + + arithOp := &planpb.BinaryArithOp{ + ColumnInfo: createColumnInfo(field), + ArithOp: funcArithOp, + RightOperand: val, + } + + return arithOp, nil +} + func (pc *parserContext) handleIdentifier(node *ant_ast.IdentifierNode) (*schemapb.FieldSchema, error) { fieldName := node.Value field, err := pc.schema.GetFieldFromName(fieldName) diff --git a/internal/proxy/plan_parser_test.go b/internal/proxy/plan_parser_test.go index 57bcfe9433..16d7898ed2 100644 --- a/internal/proxy/plan_parser_test.go +++ b/internal/proxy/plan_parser_test.go @@ -157,6 +157,66 @@ func TestParseExpr_Naive(t *testing.T) { assert.Nil(t, exprProto) } }) + + t.Run("test BinaryArithOpNode", func(t *testing.T) { + exprStrs := []string{ + // "+" + "FloatField + 1.2 == 3", + "Int64Field + 3 == 5", + "1.2 + FloatField != 3", + "3 + Int64Field != 5", + // "-" + "FloatField - 1.2 == 3", + "Int64Field - 3 != 5", + // "*" + "FloatField * 1.2 == 3", + "Int64Field * 3 == 5", + "1.2 * FloatField != 3", + "3 * Int64Field != 5", + // "/" + "FloatField / 1.2 == 3", + "Int64Field / 3 != 5", + // "%" + "Int64Field % 7 == 5", + } + for _, exprStr := range exprStrs { + exprProto, err := parseExpr(schema, exprStr) + assert.Nil(t, err) + str := proto.MarshalTextString(exprProto) + println(str) + } + }) + + t.Run("test BinaryArithOpNode invalid", func(t *testing.T) { + exprStrs := []string{ + // "+" + "FloatField + FloatField == 20", + "Int64Field + Int64Field != 10", + // "-" + "FloatField - FloatField == 20.0", + "Int64Field - Int64Field != 10", + "10 - FloatField == 20", + "20 - Int64Field != 10", + // "*" + "FloatField * FloatField == 20", + "Int64Field * Int64Field != 10", + // "/" + "FloatField / FloatField == 20", + "Int64Field / Int64Field != 10", + "FloatField / 0 == 20", + "Int64Field / 0 != 10", + // "%" + "Int64Field % Int64Field != 10", + "FloatField % 0 == 20", + "Int64Field % 0 != 10", + "FloatField % 2.3 == 20", + } + for _, exprStr := range exprStrs { + exprProto, err := parseExpr(schema, exprStr) + assert.Error(t, err) + assert.Nil(t, exprProto) + } + }) } func TestParsePlanNode_Naive(t *testing.T) { @@ -330,6 +390,79 @@ func TestExprFieldCompare_Str(t *testing.T) { } } +func TestExprBinaryArithOp_Str(t *testing.T) { + exprStrs := []string{ + // Basic arithmetic + "(age1 + 5) == 2", + // Float data type + "(FloatN - 5.2) == 0", + // Other operators + "(age1 - 5) == 1", + "(age1 * 5) == 6", + "(age1 / 5) == 1", + "(age1 % 5) == 0", + // Allow for commutative property for + and * + "(6 + age1) != 2", + "(age1 * 4) != 9", + "(5 * FloatN) != 0", + "(9 * FloatN) != 0", + } + + unsupportedExprStrs := []string{ + // Comparison operators except for "==" and "!=" are unsupported + "(age1 + 2) > 4", + "(age1 + 2) >= 4", + "(age1 + 2) < 4", + "(age1 + 2) <= 4", + // Functional nodes at the right of the comparison are not allowed + "0 == (age1 + 3)", + // Field as the right operand for -, /, and % operators are not supported + "(10 - age1) == 0", + "(20 / age1) == 0", + "(30 % age1) == 0", + // Modulo is not supported in the parser but the engine can handle it since fmod is used + "(FloatN % 2.1) == 0", + // Different data types are not supported + "(age1 + 20.16) == 35.16", + // Left operand of the function must be an identifier + "(10.5 / floatN) == 5.75", + } + + fields := []*schemapb.FieldSchema{ + {FieldID: 100, Name: "fakevec", DataType: schemapb.DataType_FloatVector}, + {FieldID: 101, Name: "age1", DataType: schemapb.DataType_Int64}, + {FieldID: 102, Name: "FloatN", DataType: schemapb.DataType_Float}, + } + + schema := &schemapb.CollectionSchema{ + Name: "default-collection", + Description: "", + AutoID: true, + Fields: fields, + } + + queryInfo := &planpb.QueryInfo{ + Topk: 10, + MetricType: "L2", + SearchParams: "{\"nprobe\": 10}", + } + + for offset, exprStr := range exprStrs { + fmt.Printf("case %d: %s\n", offset, exprStr) + planProto, err := createQueryPlan(schema, exprStr, "fakevec", queryInfo) + assert.Nil(t, err) + dbgStr := proto.MarshalTextString(planProto) + println(dbgStr) + } + for offset, exprStr := range unsupportedExprStrs { + fmt.Printf("case %d: %s\n", offset, exprStr) + planProto, err := createQueryPlan(schema, exprStr, "fakevec", queryInfo) + assert.Error(t, err) + dbgStr := proto.MarshalTextString(planProto) + println(dbgStr) + } +} + func TestPlanParseAPIs(t *testing.T) { t.Run("get compare op type", func(t *testing.T) { var op planpb.OpType