Support query by expression (#7386)

Signed-off-by: fishpenguin <kun.yu@zilliz.com>

internal/core/src/common/Types.h

@@ -83,6 +83,17 @@ struct SearchResult {
 
 using SearchResultPtr = std::shared_ptr<SearchResult>;
 
+struct RetrieveResult {
+    RetrieveResult() = default;
+
+ public:
+    void* segment_;
+    std::vector<int64_t> result_offsets_;
+    std::vector<DataArray> field_data_;
+};
+
+using RetrieveResultPtr = std::shared_ptr<RetrieveResult>;
+
 struct EntityResults {
     // use protobuf results to simplify
 };

internal/core/src/pb/plan.pb.cc

@@ -84,6 +84,7 @@ class PlanNodeDefaultTypeInternal {
  public:
   ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlanNode> _instance;
   const ::milvus::proto::plan::VectorANNS* vector_anns_;
+  const ::milvus::proto::plan::Expr* predicates_;
 } _PlanNode_default_instance_;
 }  // namespace plan
 }  // namespace proto
@@ -188,9 +189,10 @@ static void InitDefaultsscc_info_PlanNode_plan_2eproto() {
   ::milvus::proto::plan::PlanNode::InitAsDefaultInstance();
 }
 
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PlanNode_plan_2eproto =
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PlanNode_plan_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PlanNode_plan_2eproto}, {
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_PlanNode_plan_2eproto}, {
-      &scc_info_VectorANNS_plan_2eproto.base,}};
+      &scc_info_VectorANNS_plan_2eproto.base,
+      &scc_info_BinaryExpr_plan_2eproto.base,}};
 
 static void InitDefaultsscc_info_QueryInfo_plan_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
@@ -361,6 +363,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOB
   PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _oneof_case_[0]),
   ~0u,  // no _weak_field_map_
   offsetof(::milvus::proto::plan::PlanNodeDefaultTypeInternal, vector_anns_),
+  offsetof(::milvus::proto::plan::PlanNodeDefaultTypeInternal, predicates_),
   PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, output_field_ids_),
   PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, node_),
 };
@@ -441,14 +444,15 @@ const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(pr
   "y\030\001 \001(\010\022\020\n\010field_id\030\002 \001(\003\022+\n\npredicates\030"
   "\003 \001(\0132\027.milvus.proto.plan.Expr\0220\n\nquery_"
   "info\030\004 \001(\0132\034.milvus.proto.plan.QueryInfo"
-  "\022\027\n\017placeholder_tag\030\005 \001(\t\"b\n\010PlanNode\0224\n"
+  "\022\027\n\017placeholder_tag\030\005 \001(\t\"\221\001\n\010PlanNode\0224"
-  "\013vector_anns\030\001 \001(\0132\035.milvus.proto.plan.V"
+  "\n\013vector_anns\030\001 \001(\0132\035.milvus.proto.plan."
-  "ectorANNSH\000\022\030\n\020output_field_ids\030\002 \003(\003B\006\n"
+  "VectorANNSH\000\022-\n\npredicates\030\002 \001(\0132\027.milvu"
-  "\004node*n\n\006OpType\022\013\n\007Invalid\020\000\022\017\n\013GreaterT"
+  "s.proto.plan.ExprH\000\022\030\n\020output_field_ids\030"
-  "han\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010LessThan\020\003\022\r\n"
+  "\003 \003(\003B\006\n\004node*n\n\006OpType\022\013\n\007Invalid\020\000\022\017\n\013"
-  "\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010NotEqual\020\006B3Z"
+  "GreaterThan\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010LessT"
-  "1github.com/milvus-io/milvus/internal/pr"
+  "han\020\003\022\r\n\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010NotEq"
-  "oto/planpbb\006proto3"
+  "ual\020\006B3Z1github.com/milvus-io/milvus/int"
+  "ernal/proto/planpbb\006proto3"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[1] = {
   &::descriptor_table_schema_2eproto,
@@ -468,7 +472,7 @@ 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", 2138,
+  &descriptor_table_plan_2eproto_initialized, descriptor_table_protodef_plan_2eproto, "plan.proto", 2186,
   &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_sccs, descriptor_table_plan_2eproto_deps, 10, 1,
   schemas, file_default_instances, TableStruct_plan_2eproto::offsets,
   file_level_metadata_plan_2eproto, 12, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto,
@@ -5055,16 +5059,23 @@ void VectorANNS::InternalSwap(VectorANNS* other) {
 void PlanNode::InitAsDefaultInstance() {
   ::milvus::proto::plan::_PlanNode_default_instance_.vector_anns_ = const_cast< ::milvus::proto::plan::VectorANNS*>(
       ::milvus::proto::plan::VectorANNS::internal_default_instance());
+  ::milvus::proto::plan::_PlanNode_default_instance_.predicates_ = const_cast< ::milvus::proto::plan::Expr*>(
+      ::milvus::proto::plan::Expr::internal_default_instance());
 }
 class PlanNode::_Internal {
  public:
   static const ::milvus::proto::plan::VectorANNS& vector_anns(const PlanNode* msg);
+  static const ::milvus::proto::plan::Expr& predicates(const PlanNode* msg);
 };
 
 const ::milvus::proto::plan::VectorANNS&
 PlanNode::_Internal::vector_anns(const PlanNode* msg) {
   return *msg->node_.vector_anns_;
 }
+const ::milvus::proto::plan::Expr&
+PlanNode::_Internal::predicates(const PlanNode* msg) {
+  return *msg->node_.predicates_;
+}
 void PlanNode::set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
   clear_node();
@@ -5079,6 +5090,20 @@ void PlanNode::set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vect
   }
   // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.vector_anns)
 }
+void PlanNode::set_allocated_predicates(::milvus::proto::plan::Expr* predicates) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  clear_node();
+  if (predicates) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      predicates = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, predicates, submessage_arena);
+    }
+    set_has_predicates();
+    node_.predicates_ = predicates;
+  }
+  // @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.predicates)
+}
 PlanNode::PlanNode()
   : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
   SharedCtor();
@@ -5095,6 +5120,10 @@ PlanNode::PlanNode(const PlanNode& from)
       mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(from.vector_anns());
       break;
     }
+    case kPredicates: {
+      mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(from.predicates());
+      break;
+    }
     case NODE_NOT_SET: {
       break;
     }
@@ -5134,6 +5163,10 @@ void PlanNode::clear_node() {
       delete node_.vector_anns_;
       break;
     }
+    case kPredicates: {
+      delete node_.predicates_;
+      break;
+    }
     case NODE_NOT_SET: {
       break;
     }
@@ -5168,12 +5201,19 @@ const char* PlanNode::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
-      // repeated int64 output_field_ids = 2;
+      // .milvus.proto.plan.Expr predicates = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ctx->ParseMessage(mutable_predicates(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated int64 output_field_ids = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_output_field_ids(), ptr, ctx);
           CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
+        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
           add_output_field_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
           CHK_(ptr);
         } else goto handle_unusual;
@@ -5219,16 +5259,27 @@ bool PlanNode::MergePartialFromCodedStream(
         break;
       }
 
-      // repeated int64 output_field_ids = 2;
+      // .milvus.proto.plan.Expr predicates = 2;
       case 2: {
         if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_predicates()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated int64 output_field_ids = 3;
+      case 3: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
           DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                    ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                  input, this->mutable_output_field_ids())));
-        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
+        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
           DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                    ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
-                 1, 18u, input, this->mutable_output_field_ids())));
+                 1, 26u, input, this->mutable_output_field_ids())));
         } else {
           goto handle_unusual;
         }
@@ -5268,9 +5319,15 @@ void PlanNode::SerializeWithCachedSizes(
       1, _Internal::vector_anns(this), output);
   }
 
-  // repeated int64 output_field_ids = 2;
+  // .milvus.proto.plan.Expr predicates = 2;
+  if (has_predicates()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, _Internal::predicates(this), output);
+  }
+
+  // repeated int64 output_field_ids = 3;
   if (this->output_field_ids_size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
     output->WriteVarint32(_output_field_ids_cached_byte_size_.load(
         std::memory_order_relaxed));
   }
@@ -5299,10 +5356,17 @@ void PlanNode::SerializeWithCachedSizes(
         1, _Internal::vector_anns(this), target);
   }
 
-  // repeated int64 output_field_ids = 2;
+  // .milvus.proto.plan.Expr predicates = 2;
+  if (has_predicates()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, _Internal::predicates(this), target);
+  }
+
+  // repeated int64 output_field_ids = 3;
   if (this->output_field_ids_size() > 0) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
-      2,
+      3,
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
       target);
     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
@@ -5333,7 +5397,7 @@ size_t PlanNode::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // repeated int64 output_field_ids = 2;
+  // repeated int64 output_field_ids = 3;
   {
     size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       Int64Size(this->output_field_ids_);
@@ -5356,6 +5420,13 @@ size_t PlanNode::ByteSizeLong() const {
           *node_.vector_anns_);
       break;
     }
+    // .milvus.proto.plan.Expr predicates = 2;
+    case kPredicates: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *node_.predicates_);
+      break;
+    }
     case NODE_NOT_SET: {
       break;
     }
@@ -5393,6 +5464,10 @@ void PlanNode::MergeFrom(const PlanNode& from) {
       mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(from.vector_anns());
       break;
     }
+    case kPredicates: {
+      mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(from.predicates());
+      break;
+    }
     case NODE_NOT_SET: {
       break;
     }

internal/core/src/pb/plan.pb.h

@@ -2072,6 +2072,7 @@ class PlanNode :
 
   enum NodeCase {
     kVectorAnns = 1,
+    kPredicates = 2,
     NODE_NOT_SET = 0,
   };
 
@@ -2152,10 +2153,11 @@ class PlanNode :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kOutputFieldIdsFieldNumber = 2,
+    kOutputFieldIdsFieldNumber = 3,
     kVectorAnnsFieldNumber = 1,
+    kPredicatesFieldNumber = 2,
   };
-  // repeated int64 output_field_ids = 2;
+  // repeated int64 output_field_ids = 3;
   int output_field_ids_size() const;
   void clear_output_field_ids();
   ::PROTOBUF_NAMESPACE_ID::int64 output_field_ids(int index) const;
@@ -2174,12 +2176,21 @@ class PlanNode :
   ::milvus::proto::plan::VectorANNS* mutable_vector_anns();
   void set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns);
 
+  // .milvus.proto.plan.Expr predicates = 2;
+  bool has_predicates() const;
+  void clear_predicates();
+  const ::milvus::proto::plan::Expr& predicates() const;
+  ::milvus::proto::plan::Expr* release_predicates();
+  ::milvus::proto::plan::Expr* mutable_predicates();
+  void set_allocated_predicates(::milvus::proto::plan::Expr* predicates);
+
   void clear_node();
   NodeCase node_case() const;
   // @@protoc_insertion_point(class_scope:milvus.proto.plan.PlanNode)
  private:
   class _Internal;
   void set_has_vector_anns();
+  void set_has_predicates();
 
   inline bool has_node() const;
   inline void clear_has_node();
@@ -2190,6 +2201,7 @@ class PlanNode :
   union NodeUnion {
     NodeUnion() {}
     ::milvus::proto::plan::VectorANNS* vector_anns_;
+    ::milvus::proto::plan::Expr* predicates_;
   } node_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
@@ -3671,7 +3683,48 @@ inline ::milvus::proto::plan::VectorANNS* PlanNode::mutable_vector_anns() {
   return node_.vector_anns_;
 }
 
-// repeated int64 output_field_ids = 2;
+// .milvus.proto.plan.Expr predicates = 2;
+inline bool PlanNode::has_predicates() const {
+  return node_case() == kPredicates;
+}
+inline void PlanNode::set_has_predicates() {
+  _oneof_case_[0] = kPredicates;
+}
+inline void PlanNode::clear_predicates() {
+  if (has_predicates()) {
+    delete node_.predicates_;
+    clear_has_node();
+  }
+}
+inline ::milvus::proto::plan::Expr* PlanNode::release_predicates() {
+  // @@protoc_insertion_point(field_release:milvus.proto.plan.PlanNode.predicates)
+  if (has_predicates()) {
+    clear_has_node();
+      ::milvus::proto::plan::Expr* temp = node_.predicates_;
+    node_.predicates_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::milvus::proto::plan::Expr& PlanNode::predicates() const {
+  // @@protoc_insertion_point(field_get:milvus.proto.plan.PlanNode.predicates)
+  return has_predicates()
+      ? *node_.predicates_
+      : *reinterpret_cast< ::milvus::proto::plan::Expr*>(&::milvus::proto::plan::_Expr_default_instance_);
+}
+inline ::milvus::proto::plan::Expr* PlanNode::mutable_predicates() {
+  if (!has_predicates()) {
+    clear_node();
+    set_has_predicates();
+    node_.predicates_ = CreateMaybeMessage< ::milvus::proto::plan::Expr >(
+        GetArenaNoVirtual());
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.proto.plan.PlanNode.predicates)
+  return node_.predicates_;
+}
+
+// repeated int64 output_field_ids = 3;
 inline int PlanNode::output_field_ids_size() const {
   return output_field_ids_.size();
 }

internal/core/src/pb/segcore.pb.cc

@@ -21,10 +21,6 @@ extern PROTOBUF_INTERNAL_EXPORT_segcore_2eproto ::PROTOBUF_NAMESPACE_ID::interna
 namespace milvus {
 namespace proto {
 namespace segcore {
-class RetrieveRequestDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RetrieveRequest> _instance;
-} _RetrieveRequest_default_instance_;
 class RetrieveResultsDefaultTypeInternal {
  public:
   ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RetrieveResults> _instance;
@@ -69,21 +65,6 @@ static void InitDefaultsscc_info_LoadSegmentMeta_segcore_2eproto() {
     {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_LoadSegmentMeta_segcore_2eproto}, {
       &scc_info_LoadFieldMeta_segcore_2eproto.base,}};
 
-static void InitDefaultsscc_info_RetrieveRequest_segcore_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::milvus::proto::segcore::_RetrieveRequest_default_instance_;
-    new (ptr) ::milvus::proto::segcore::RetrieveRequest();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::milvus::proto::segcore::RetrieveRequest::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RetrieveRequest_segcore_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_RetrieveRequest_segcore_2eproto}, {
-      &scc_info_IDs_schema_2eproto.base,}};
-
 static void InitDefaultsscc_info_RetrieveResults_segcore_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
@@ -100,18 +81,11 @@ static void InitDefaultsscc_info_RetrieveResults_segcore_2eproto() {
       &scc_info_IDs_schema_2eproto.base,
       &scc_info_FieldData_schema_2eproto.base,}};
 
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_segcore_2eproto[4];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_segcore_2eproto[3];
 static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_segcore_2eproto = nullptr;
 static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_segcore_2eproto = nullptr;
 
 const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_segcore_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveRequest, _internal_metadata_),
-  ~0u,  // no _extensions_
-  ~0u,  // no _oneof_case_
-  ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveRequest, ids_),
-  PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveRequest, output_fields_id_),
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveResults, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -137,14 +111,12 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_segcore_2eproto::offsets[] PRO
   PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::LoadSegmentMeta, total_size_),
 };
 static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, -1, sizeof(::milvus::proto::segcore::RetrieveRequest)},
+  { 0, -1, sizeof(::milvus::proto::segcore::RetrieveResults)},
-  { 7, -1, sizeof(::milvus::proto::segcore::RetrieveResults)},
+  { 8, -1, sizeof(::milvus::proto::segcore::LoadFieldMeta)},
-  { 15, -1, sizeof(::milvus::proto::segcore::LoadFieldMeta)},
+  { 16, -1, sizeof(::milvus::proto::segcore::LoadSegmentMeta)},
-  { 23, -1, sizeof(::milvus::proto::segcore::LoadSegmentMeta)},
 };
 
 static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_RetrieveRequest_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_RetrieveResults_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_LoadFieldMeta_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_LoadSegmentMeta_default_instance_),
@@ -152,35 +124,32 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] =
 
 const char descriptor_table_protodef_segcore_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
   "\n\rsegcore.proto\022\024milvus.proto.segcore\032\014s"
-  "chema.proto\"R\n\017RetrieveRequest\022%\n\003ids\030\001 "
+  "chema.proto\"}\n\017RetrieveResults\022%\n\003ids\030\001 "
-  "\001(\0132\030.milvus.proto.schema.IDs\022\030\n\020output_"
+  "\001(\0132\030.milvus.proto.schema.IDs\022\016\n\006offset\030"
-  "fields_id\030\002 \003(\003\"}\n\017RetrieveResults\022%\n\003id"
+  "\002 \003(\003\0223\n\013fields_data\030\003 \003(\0132\036.milvus.prot"
-  "s\030\001 \001(\0132\030.milvus.proto.schema.IDs\022\016\n\006off"
+  "o.schema.FieldData\"P\n\rLoadFieldMeta\022\025\n\rm"
-  "set\030\002 \003(\003\0223\n\013fields_data\030\003 \003(\0132\036.milvus."
+  "in_timestamp\030\001 \001(\003\022\025\n\rmax_timestamp\030\002 \001("
-  "proto.schema.FieldData\"P\n\rLoadFieldMeta\022"
+  "\003\022\021\n\trow_count\030\003 \001(\003\"Y\n\017LoadSegmentMeta\022"
-  "\025\n\rmin_timestamp\030\001 \001(\003\022\025\n\rmax_timestamp\030"
+  "2\n\005metas\030\001 \003(\0132#.milvus.proto.segcore.Lo"
-  "\002 \001(\003\022\021\n\trow_count\030\003 \001(\003\"Y\n\017LoadSegmentM"
+  "adFieldMeta\022\022\n\ntotal_size\030\002 \001(\003B6Z4githu"
-  "eta\0222\n\005metas\030\001 \003(\0132#.milvus.proto.segcor"
+  "b.com/milvus-io/milvus/internal/proto/se"
-  "e.LoadFieldMeta\022\022\n\ntotal_size\030\002 \001(\003B6Z4g"
+  "gcorepbb\006proto3"
-  "ithub.com/milvus-io/milvus/internal/prot"
-  "o/segcorepbb\006proto3"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_segcore_2eproto_deps[1] = {
   &::descriptor_table_schema_2eproto,
 };
-static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_segcore_2eproto_sccs[4] = {
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_segcore_2eproto_sccs[3] = {
   &scc_info_LoadFieldMeta_segcore_2eproto.base,
   &scc_info_LoadSegmentMeta_segcore_2eproto.base,
-  &scc_info_RetrieveRequest_segcore_2eproto.base,
   &scc_info_RetrieveResults_segcore_2eproto.base,
 };
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_segcore_2eproto_once;
 static bool descriptor_table_segcore_2eproto_initialized = false;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_segcore_2eproto = {
-  &descriptor_table_segcore_2eproto_initialized, descriptor_table_protodef_segcore_2eproto, "segcore.proto", 499,
+  &descriptor_table_segcore_2eproto_initialized, descriptor_table_protodef_segcore_2eproto, "segcore.proto", 415,
-  &descriptor_table_segcore_2eproto_once, descriptor_table_segcore_2eproto_sccs, descriptor_table_segcore_2eproto_deps, 4, 1,
+  &descriptor_table_segcore_2eproto_once, descriptor_table_segcore_2eproto_sccs, descriptor_table_segcore_2eproto_deps, 3, 1,
   schemas, file_default_instances, TableStruct_segcore_2eproto::offsets,
-  file_level_metadata_segcore_2eproto, 4, file_level_enum_descriptors_segcore_2eproto, file_level_service_descriptors_segcore_2eproto,
+  file_level_metadata_segcore_2eproto, 3, file_level_enum_descriptors_segcore_2eproto, file_level_service_descriptors_segcore_2eproto,
 };
 
 // Force running AddDescriptors() at dynamic initialization time.
@@ -189,347 +158,6 @@ namespace milvus {
 namespace proto {
 namespace segcore {
 
-// ===================================================================
-
-void RetrieveRequest::InitAsDefaultInstance() {
-  ::milvus::proto::segcore::_RetrieveRequest_default_instance_._instance.get_mutable()->ids_ = const_cast< ::milvus::proto::schema::IDs*>(
-      ::milvus::proto::schema::IDs::internal_default_instance());
-}
-class RetrieveRequest::_Internal {
- public:
-  static const ::milvus::proto::schema::IDs& ids(const RetrieveRequest* msg);
-};
-
-const ::milvus::proto::schema::IDs&
-RetrieveRequest::_Internal::ids(const RetrieveRequest* msg) {
-  return *msg->ids_;
-}
-void RetrieveRequest::clear_ids() {
-  if (GetArenaNoVirtual() == nullptr && ids_ != nullptr) {
-    delete ids_;
-  }
-  ids_ = nullptr;
-}
-RetrieveRequest::RetrieveRequest()
-  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:milvus.proto.segcore.RetrieveRequest)
-}
-RetrieveRequest::RetrieveRequest(const RetrieveRequest& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message(),
-      _internal_metadata_(nullptr),
-      output_fields_id_(from.output_fields_id_) {
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  if (from.has_ids()) {
-    ids_ = new ::milvus::proto::schema::IDs(*from.ids_);
-  } else {
-    ids_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:milvus.proto.segcore.RetrieveRequest)
-}
-
-void RetrieveRequest::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RetrieveRequest_segcore_2eproto.base);
-  ids_ = nullptr;
-}
-
-RetrieveRequest::~RetrieveRequest() {
-  // @@protoc_insertion_point(destructor:milvus.proto.segcore.RetrieveRequest)
-  SharedDtor();
-}
-
-void RetrieveRequest::SharedDtor() {
-  if (this != internal_default_instance()) delete ids_;
-}
-
-void RetrieveRequest::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const RetrieveRequest& RetrieveRequest::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RetrieveRequest_segcore_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void RetrieveRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:milvus.proto.segcore.RetrieveRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  output_fields_id_.Clear();
-  if (GetArenaNoVirtual() == nullptr && ids_ != nullptr) {
-    delete ids_;
-  }
-  ids_ = nullptr;
-  _internal_metadata_.Clear();
-}
-
-#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
-const char* RetrieveRequest::_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.schema.IDs ids = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(mutable_ids(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 output_fields_id = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_output_fields_id(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
-          add_output_fields_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
-bool RetrieveRequest::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.segcore.RetrieveRequest)
-  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.schema.IDs ids = 1;
-      case 1: {
-        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
-          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
-               input, mutable_ids()));
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
-      // repeated int64 output_fields_id = 2;
-      case 2: {
-        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
-          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
-                 input, this->mutable_output_fields_id())));
-        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
-          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
-                 1, 18u, input, this->mutable_output_fields_id())));
-        } 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.segcore.RetrieveRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:milvus.proto.segcore.RetrieveRequest)
-  return false;
-#undef DO_
-}
-#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
-
-void RetrieveRequest::SerializeWithCachedSizes(
-    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:milvus.proto.segcore.RetrieveRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .milvus.proto.schema.IDs ids = 1;
-  if (this->has_ids()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, _Internal::ids(this), output);
-  }
-
-  // repeated int64 output_fields_id = 2;
-  if (this->output_fields_id_size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_output_fields_id_cached_byte_size_.load(
-        std::memory_order_relaxed));
-  }
-  for (int i = 0, n = this->output_fields_id_size(); i < n; i++) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag(
-      this->output_fields_id(i), output);
-  }
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
-        _internal_metadata_.unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:milvus.proto.segcore.RetrieveRequest)
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* RetrieveRequest::InternalSerializeWithCachedSizesToArray(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.segcore.RetrieveRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .milvus.proto.schema.IDs ids = 1;
-  if (this->has_ids()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessageToArray(
-        1, _Internal::ids(this), target);
-  }
-
-  // repeated int64 output_fields_id = 2;
-  if (this->output_fields_id_size() > 0) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
-      2,
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
-        _output_fields_id_cached_byte_size_.load(std::memory_order_relaxed),
-         target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      WriteInt64NoTagToArray(this->output_fields_id_, 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.segcore.RetrieveRequest)
-  return target;
-}
-
-size_t RetrieveRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:milvus.proto.segcore.RetrieveRequest)
-  size_t total_size = 0;
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
-        _internal_metadata_.unknown_fields());
-  }
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 output_fields_id = 2;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->output_fields_id_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _output_fields_id_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // .milvus.proto.schema.IDs ids = 1;
-  if (this->has_ids()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *ids_);
-  }
-
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void RetrieveRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.segcore.RetrieveRequest)
-  GOOGLE_DCHECK_NE(&from, this);
-  const RetrieveRequest* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RetrieveRequest>(
-          &from);
-  if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.segcore.RetrieveRequest)
-    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.segcore.RetrieveRequest)
-    MergeFrom(*source);
-  }
-}
-
-void RetrieveRequest::MergeFrom(const RetrieveRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.segcore.RetrieveRequest)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  output_fields_id_.MergeFrom(from.output_fields_id_);
-  if (from.has_ids()) {
-    mutable_ids()->::milvus::proto::schema::IDs::MergeFrom(from.ids());
-  }
-}
-
-void RetrieveRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.segcore.RetrieveRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void RetrieveRequest::CopyFrom(const RetrieveRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.segcore.RetrieveRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool RetrieveRequest::IsInitialized() const {
-  return true;
-}
-
-void RetrieveRequest::InternalSwap(RetrieveRequest* other) {
-  using std::swap;
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  output_fields_id_.InternalSwap(&other->output_fields_id_);
-  swap(ids_, other->ids_);
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata RetrieveRequest::GetMetadata() const {
-  return GetMetadataStatic();
-}
-
-
 // ===================================================================
 
 void RetrieveResults::InitAsDefaultInstance() {
@@ -1576,9 +1204,6 @@ void LoadSegmentMeta::InternalSwap(LoadSegmentMeta* other) {
 }  // namespace proto
 }  // namespace milvus
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::milvus::proto::segcore::RetrieveRequest* Arena::CreateMaybeMessage< ::milvus::proto::segcore::RetrieveRequest >(Arena* arena) {
-  return Arena::CreateInternal< ::milvus::proto::segcore::RetrieveRequest >(arena);
-}
 template<> PROTOBUF_NOINLINE ::milvus::proto::segcore::RetrieveResults* Arena::CreateMaybeMessage< ::milvus::proto::segcore::RetrieveResults >(Arena* arena) {
   return Arena::CreateInternal< ::milvus::proto::segcore::RetrieveResults >(arena);
 }

internal/core/src/pb/segcore.pb.h

@@ -48,7 +48,7 @@ struct TableStruct_segcore_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[4]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -64,9 +64,6 @@ extern LoadFieldMetaDefaultTypeInternal _LoadFieldMeta_default_instance_;
 class LoadSegmentMeta;
 class LoadSegmentMetaDefaultTypeInternal;
 extern LoadSegmentMetaDefaultTypeInternal _LoadSegmentMeta_default_instance_;
-class RetrieveRequest;
-class RetrieveRequestDefaultTypeInternal;
-extern RetrieveRequestDefaultTypeInternal _RetrieveRequest_default_instance_;
 class RetrieveResults;
 class RetrieveResultsDefaultTypeInternal;
 extern RetrieveResultsDefaultTypeInternal _RetrieveResults_default_instance_;
@@ -76,7 +73,6 @@ extern RetrieveResultsDefaultTypeInternal _RetrieveResults_default_instance_;
 PROTOBUF_NAMESPACE_OPEN
 template<> ::milvus::proto::segcore::LoadFieldMeta* Arena::CreateMaybeMessage<::milvus::proto::segcore::LoadFieldMeta>(Arena*);
 template<> ::milvus::proto::segcore::LoadSegmentMeta* Arena::CreateMaybeMessage<::milvus::proto::segcore::LoadSegmentMeta>(Arena*);
-template<> ::milvus::proto::segcore::RetrieveRequest* Arena::CreateMaybeMessage<::milvus::proto::segcore::RetrieveRequest>(Arena*);
 template<> ::milvus::proto::segcore::RetrieveResults* Arena::CreateMaybeMessage<::milvus::proto::segcore::RetrieveResults>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace milvus {
@@ -85,154 +81,6 @@ namespace segcore {
 
 // ===================================================================
 
-class RetrieveRequest :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.segcore.RetrieveRequest) */ {
- public:
-  RetrieveRequest();
-  virtual ~RetrieveRequest();
-
-  RetrieveRequest(const RetrieveRequest& from);
-  RetrieveRequest(RetrieveRequest&& from) noexcept
-    : RetrieveRequest() {
-    *this = ::std::move(from);
-  }
-
-  inline RetrieveRequest& operator=(const RetrieveRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline RetrieveRequest& operator=(RetrieveRequest&& 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 RetrieveRequest& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const RetrieveRequest* internal_default_instance() {
-    return reinterpret_cast<const RetrieveRequest*>(
-               &_RetrieveRequest_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(RetrieveRequest& a, RetrieveRequest& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(RetrieveRequest* other) {
-    if (other == this) return;
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline RetrieveRequest* New() const final {
-    return CreateMaybeMessage<RetrieveRequest>(nullptr);
-  }
-
-  RetrieveRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<RetrieveRequest>(arena);
-  }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const RetrieveRequest& from);
-  void MergeFrom(const RetrieveRequest& 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(RetrieveRequest* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "milvus.proto.segcore.RetrieveRequest";
-  }
-  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_segcore_2eproto);
-    return ::descriptor_table_segcore_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
-
-  public:
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOutputFieldsIdFieldNumber = 2,
-    kIdsFieldNumber = 1,
-  };
-  // repeated int64 output_fields_id = 2;
-  int output_fields_id_size() const;
-  void clear_output_fields_id();
-  ::PROTOBUF_NAMESPACE_ID::int64 output_fields_id(int index) const;
-  void set_output_fields_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_output_fields_id(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      output_fields_id() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_output_fields_id();
-
-  // .milvus.proto.schema.IDs ids = 1;
-  bool has_ids() const;
-  void clear_ids();
-  const ::milvus::proto::schema::IDs& ids() const;
-  ::milvus::proto::schema::IDs* release_ids();
-  ::milvus::proto::schema::IDs* mutable_ids();
-  void set_allocated_ids(::milvus::proto::schema::IDs* ids);
-
-  // @@protoc_insertion_point(class_scope:milvus.proto.segcore.RetrieveRequest)
- private:
-  class _Internal;
-
-  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > output_fields_id_;
-  mutable std::atomic<int> _output_fields_id_cached_byte_size_;
-  ::milvus::proto::schema::IDs* ids_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_segcore_2eproto;
-};
-// -------------------------------------------------------------------
-
 class RetrieveResults :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.segcore.RetrieveResults) */ {
  public:
@@ -275,7 +123,7 @@ class RetrieveResults :
                &_RetrieveResults_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    1;
+    0;
 
   friend void swap(RetrieveResults& a, RetrieveResults& b) {
     a.Swap(&b);
@@ -436,7 +284,7 @@ class LoadFieldMeta :
                &_LoadFieldMeta_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    2;
+    1;
 
   friend void swap(LoadFieldMeta& a, LoadFieldMeta& b) {
     a.Swap(&b);
@@ -581,7 +429,7 @@ class LoadSegmentMeta :
                &_LoadSegmentMeta_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    3;
+    2;
 
   friend void swap(LoadSegmentMeta& a, LoadSegmentMeta& b) {
     a.Swap(&b);
@@ -690,85 +538,6 @@ class LoadSegmentMeta :
   #pragma GCC diagnostic push
   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
-// RetrieveRequest
-
-// .milvus.proto.schema.IDs ids = 1;
-inline bool RetrieveRequest::has_ids() const {
-  return this != internal_default_instance() && ids_ != nullptr;
-}
-inline const ::milvus::proto::schema::IDs& RetrieveRequest::ids() const {
-  const ::milvus::proto::schema::IDs* p = ids_;
-  // @@protoc_insertion_point(field_get:milvus.proto.segcore.RetrieveRequest.ids)
-  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::schema::IDs*>(
-      &::milvus::proto::schema::_IDs_default_instance_);
-}
-inline ::milvus::proto::schema::IDs* RetrieveRequest::release_ids() {
-  // @@protoc_insertion_point(field_release:milvus.proto.segcore.RetrieveRequest.ids)
-  
-  ::milvus::proto::schema::IDs* temp = ids_;
-  ids_ = nullptr;
-  return temp;
-}
-inline ::milvus::proto::schema::IDs* RetrieveRequest::mutable_ids() {
-  
-  if (ids_ == nullptr) {
-    auto* p = CreateMaybeMessage<::milvus::proto::schema::IDs>(GetArenaNoVirtual());
-    ids_ = p;
-  }
-  // @@protoc_insertion_point(field_mutable:milvus.proto.segcore.RetrieveRequest.ids)
-  return ids_;
-}
-inline void RetrieveRequest::set_allocated_ids(::milvus::proto::schema::IDs* ids) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
-  if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(ids_);
-  }
-  if (ids) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
-    if (message_arena != submessage_arena) {
-      ids = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, ids, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  ids_ = ids;
-  // @@protoc_insertion_point(field_set_allocated:milvus.proto.segcore.RetrieveRequest.ids)
-}
-
-// repeated int64 output_fields_id = 2;
-inline int RetrieveRequest::output_fields_id_size() const {
-  return output_fields_id_.size();
-}
-inline void RetrieveRequest::clear_output_fields_id() {
-  output_fields_id_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 RetrieveRequest::output_fields_id(int index) const {
-  // @@protoc_insertion_point(field_get:milvus.proto.segcore.RetrieveRequest.output_fields_id)
-  return output_fields_id_.Get(index);
-}
-inline void RetrieveRequest::set_output_fields_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  output_fields_id_.Set(index, value);
-  // @@protoc_insertion_point(field_set:milvus.proto.segcore.RetrieveRequest.output_fields_id)
-}
-inline void RetrieveRequest::add_output_fields_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  output_fields_id_.Add(value);
-  // @@protoc_insertion_point(field_add:milvus.proto.segcore.RetrieveRequest.output_fields_id)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-RetrieveRequest::output_fields_id() const {
-  // @@protoc_insertion_point(field_list:milvus.proto.segcore.RetrieveRequest.output_fields_id)
-  return output_fields_id_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-RetrieveRequest::mutable_output_fields_id() {
-  // @@protoc_insertion_point(field_mutable_list:milvus.proto.segcore.RetrieveRequest.output_fields_id)
-  return &output_fields_id_;
-}
-
-// -------------------------------------------------------------------
-
 // RetrieveResults
 
 // .milvus.proto.schema.IDs ids = 1;
@@ -974,8 +743,6 @@ inline void LoadSegmentMeta::set_total_size(::PROTOBUF_NAMESPACE_ID::int64 value
 
 // -------------------------------------------------------------------
 
-// -------------------------------------------------------------------
-
 
 // @@protoc_insertion_point(namespace_scope)
 

internal/core/src/query/Plan.cpp

@@ -396,6 +396,13 @@ CreatePlanByExpr(const Schema& schema, const char* serialized_expr_plan, int64_t
     return ProtoParser(schema).CreatePlan(plan_node);
 }
 
+std::unique_ptr<RetrievePlan>
+CreateRetrievePlanByExpr(const Schema& schema, const char* serialized_expr_plan, int size) {
+    proto::plan::PlanNode plan_node;
+    plan_node.ParseFromArray(serialized_expr_plan, size);
+    return ProtoParser(schema).CreateRetrievePlan(plan_node);
+}
+
 std::vector<ExprPtr>
 Parser::ParseItemList(const Json& body) {
     std::vector<ExprPtr> results;
@@ -546,15 +553,15 @@ GetNumOfQueries(const PlaceholderGroup* group) {
     return group->at(0).num_of_queries_;
 }
 
-std::unique_ptr<RetrievePlan>
+// std::unique_ptr<RetrievePlan>
-CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request) {
+// CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request) {
-    auto plan = std::make_unique<RetrievePlan>();
+//    auto plan = std::make_unique<RetrievePlan>();
-    plan->ids_ = std::unique_ptr<proto::schema::IDs>(request.release_ids());
+//    plan->ids_ = std::unique_ptr<proto::schema::IDs>(request.release_ids());
-    for (auto& field_id : request.output_fields_id()) {
+//    for (auto& field_id : request.output_fields_id()) {
-        plan->field_offsets_.push_back(schema.get_offset(FieldId(field_id)));
+//        plan->field_offsets_.push_back(schema.get_offset(FieldId(field_id)));
-    }
+//    }
-    return plan;
+//    return plan;
-}
+//}
 
 void
 Plan::check_identical(Plan& other) {

internal/core/src/query/Plan.h

@@ -38,8 +38,11 @@ ParsePlaceholderGroup(const Plan* plan, const std::string& placeholder_group_blo
 int64_t
 GetNumOfQueries(const PlaceholderGroup*);
 
+// std::unique_ptr<RetrievePlan>
+// CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request);
+
 std::unique_ptr<RetrievePlan>
-CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request);
+CreateRetrievePlanByExpr(const Schema& schema, const char* serialized_expr_plan, int size);
 
 // Query Overall TopK from Plan
 // Used to alloc result memory at Go side

internal/core/src/query/PlanImpl.h

@@ -81,7 +81,13 @@ struct Placeholder {
 };
 
 struct RetrievePlan {
-    std::unique_ptr<proto::schema::IDs> ids_;
+ public:
+    explicit RetrievePlan(const Schema& schema) : schema_(schema) {
+    }
+
+ public:
+    const Schema& schema_;
+    std::unique_ptr<RetrievePlanNode> plan_node_;
     std::vector<FieldOffset> field_offsets_;
 };
 

internal/core/src/query/PlanNode.h

@@ -55,4 +55,12 @@ struct BinaryVectorANNS : VectorPlanNode {
     accept(PlanNodeVisitor&) override;
 };
 
+struct RetrievePlanNode : PlanNode {
+ public:
+    void
+    accept(PlanNodeVisitor&) override;
+
+    ExprPtr predicate_;
+};
+
 }  // namespace milvus::query

internal/core/src/query/PlanProto.cpp

@@ -137,6 +137,17 @@ ProtoParser::PlanNodeFromProto(const planpb::PlanNode& plan_node_proto) {
     return plan_node;
 }
 
+std::unique_ptr<RetrievePlanNode>
+ProtoParser::RetrievePlanNodeFromProto(const planpb::PlanNode& plan_node_proto) {
+    Assert(plan_node_proto.has_predicates());
+    auto& predicate_proto = plan_node_proto.predicates();
+    auto expr_opt = [&]() -> ExprPtr { return ParseExpr(predicate_proto); }();
+
+    auto plan_node = [&]() -> std::unique_ptr<RetrievePlanNode> { return std::make_unique<RetrievePlanNode>(); }();
+    plan_node->predicate_ = std::move(expr_opt);
+    return plan_node;
+}
+
 std::unique_ptr<Plan>
 ProtoParser::CreatePlan(const proto::plan::PlanNode& plan_node_proto) {
     auto plan = std::make_unique<Plan>(schema);
@@ -159,6 +170,24 @@ ProtoParser::CreatePlan(const proto::plan::PlanNode& plan_node_proto) {
     return plan;
 }
 
+std::unique_ptr<RetrievePlan>
+ProtoParser::CreateRetrievePlan(const proto::plan::PlanNode& plan_node_proto) {
+    auto retrieve_plan = std::make_unique<RetrievePlan>(schema);
+
+    auto plan_node = RetrievePlanNodeFromProto(plan_node_proto);
+    ExtractedPlanInfo plan_info(schema.size());
+    ExtractInfoPlanNodeVisitor extractor(plan_info);
+    plan_node->accept(extractor);
+
+    retrieve_plan->plan_node_ = std::move(plan_node);
+    for (auto field_id_raw : plan_node_proto.output_field_ids()) {
+        auto field_id = FieldId(field_id_raw);
+        auto offset = schema.get_offset(field_id);
+        retrieve_plan->field_offsets_.push_back(offset);
+    }
+    return retrieve_plan;
+}
+
 ExprPtr
 ProtoParser::ParseUnaryRangeExpr(const proto::plan::UnaryRangeExpr& expr_pb) {
     auto& column_info = expr_pb.column_info();

internal/core/src/query/PlanProto.h

@@ -50,9 +50,15 @@ class ProtoParser {
     std::unique_ptr<VectorPlanNode>
     PlanNodeFromProto(const proto::plan::PlanNode& plan_node_proto);
 
+    std::unique_ptr<RetrievePlanNode>
+    RetrievePlanNodeFromProto(const proto::plan::PlanNode& plan_node_proto);
+
     std::unique_ptr<Plan>
     CreatePlan(const proto::plan::PlanNode& plan_node_proto);
 
+    std::unique_ptr<RetrievePlan>
+    CreateRetrievePlan(const proto::plan::PlanNode& plan_node_proto);
+
  private:
     const Schema& schema;
     // boost::dynamic_bitset<> involved_fields;

internal/core/src/query/generated/ExecPlanNodeVisitor.h

@@ -27,14 +27,21 @@ class ExecPlanNodeVisitor : public PlanNodeVisitor {
     void
     visit(BinaryVectorANNS& node) override;
 
+    void
+    visit(RetrievePlanNode& node);
+
  public:
     using RetType = SearchResult;
+    using RetrieveRetType = RetrieveResult;
     ExecPlanNodeVisitor(const segcore::SegmentInterface& segment,
                         Timestamp timestamp,
                         const PlaceholderGroup& placeholder_group)
         : segment_(segment), timestamp_(timestamp), placeholder_group_(placeholder_group) {
     }
-    // using RetType = nlohmann::json;
+
+    ExecPlanNodeVisitor(const segcore::SegmentInterface& segment, Timestamp timestamp)
+        : segment_(segment), timestamp_(timestamp) {
+    }
 
     RetType
     get_moved_result(PlanNode& node) {
@@ -46,6 +53,17 @@ class ExecPlanNodeVisitor : public PlanNodeVisitor {
         return ret;
     }
 
+    RetrieveRetType
+    get_retrieve_result(PlanNode& node) {
+        assert(!retrieve_ret_.has_value());
+        std::cout.flush();
+        node.accept(*this);
+        assert(retrieve_ret_.has_value());
+        auto retrieve_ret = std::move(retrieve_ret_).value();
+        retrieve_ret_ = std::nullopt;
+        return retrieve_ret;
+    }
+
  private:
     template <typename VectorType>
     void
@@ -55,8 +73,9 @@ class ExecPlanNodeVisitor : public PlanNodeVisitor {
     // std::optional<RetType> ret_;
     const segcore::SegmentInterface& segment_;
     Timestamp timestamp_;
-    const PlaceholderGroup& placeholder_group_;
+    PlaceholderGroup placeholder_group_;
 
     std::optional<RetType> ret_;
+    std::optional<RetrieveResult> retrieve_ret_;
 };
 }  // namespace milvus::query

internal/core/src/query/generated/ExtractInfoPlanNodeVisitor.h

@@ -24,6 +24,9 @@ class ExtractInfoPlanNodeVisitor : public PlanNodeVisitor {
     void
     visit(BinaryVectorANNS& node) override;
 
+    void
+    visit(RetrievePlanNode& node);
+
  public:
     explicit ExtractInfoPlanNodeVisitor(ExtractedPlanInfo& plan_info) : plan_info_(plan_info) {
     }

internal/core/src/query/generated/PlanNode.cpp

@@ -25,4 +25,9 @@ BinaryVectorANNS::accept(PlanNodeVisitor& visitor) {
     visitor.visit(*this);
 }
 
+void
+RetrievePlanNode::accept(PlanNodeVisitor& visitor) {
+    visitor.visit(*this);
+}
+
 }  // namespace milvus::query

internal/core/src/query/generated/PlanNodeVisitor.h

@@ -24,5 +24,8 @@ class PlanNodeVisitor {
 
     virtual void
     visit(BinaryVectorANNS&) = 0;
+
+    virtual void
+    visit(RetrievePlanNode&) = 0;
 };
 }  // namespace milvus::query

internal/core/src/query/generated/ShowPlanNodeVisitor.h

@@ -28,6 +28,9 @@ class ShowPlanNodeVisitor : public PlanNodeVisitor {
     void
     visit(BinaryVectorANNS& node) override;
 
+    void
+    visit(RetrievePlanNode& node) override;
+
  public:
     using RetType = nlohmann::json;
 

internal/core/src/query/generated/VerifyPlanNodeVisitor.h

@@ -27,6 +27,9 @@ class VerifyPlanNodeVisitor : public PlanNodeVisitor {
     void
     visit(BinaryVectorANNS& node) override;
 
+    void
+    visit(RetrievePlanNode& node) override;
+
  public:
     using RetType = SearchResult;
     VerifyPlanNodeVisitor() = default;

internal/core/src/query/visitors/ExecPlanNodeVisitor.cpp

@@ -114,6 +114,33 @@ ExecPlanNodeVisitor::VectorVisitorImpl(VectorPlanNode& node) {
     ret_ = ret;
 }
 
+void
+ExecPlanNodeVisitor::visit(RetrievePlanNode& node) {
+    assert(!retrieve_ret_.has_value());
+    auto segment = dynamic_cast<const segcore::SegmentInternalInterface*>(&segment_);
+    AssertInfo(segment, "Support SegmentSmallIndex Only");
+    RetrieveRetType ret;
+
+    boost::dynamic_bitset<> bitset_holder;
+    auto active_count = segment->get_active_count(timestamp_);
+
+    if (active_count == 0) {
+        return;
+    }
+
+    if (node.predicate_ != nullptr) {
+        ExecExprVisitor::RetType expr_ret =
+            ExecExprVisitor(*segment, active_count, timestamp_).call_child(*(node.predicate_));
+        bitset_holder = std::move(expr_ret);
+    }
+
+    segment->mask_with_timestamps(bitset_holder, timestamp_);
+
+    auto seg_offsets = std::move(segment->search_ids(bitset_holder, MAX_TIMESTAMP));
+    ret.result_offsets_.assign((int64_t*)seg_offsets.data(), (int64_t*)seg_offsets.data() + seg_offsets.size());
+    retrieve_ret_ = ret;
+}
+
 void
 ExecPlanNodeVisitor::visit(FloatVectorANNS& node) {
     VectorVisitorImpl<FloatVector>(node);

internal/core/src/query/visitors/ExtractInfoPlanNodeVisitor.cpp

@@ -48,4 +48,11 @@ ExtractInfoPlanNodeVisitor::visit(BinaryVectorANNS& node) {
     }
 }
 
+void
+ExtractInfoPlanNodeVisitor::visit(RetrievePlanNode& node) {
+    // Assert(node.predicate_.has_value());
+    ExtractInfoExprVisitor expr_visitor(plan_info_);
+    node.predicate_->accept(expr_visitor);
+}
+
 }  // namespace milvus::query

internal/core/src/query/visitors/ShowPlanNodeVisitor.cpp

@@ -93,4 +93,8 @@ ShowPlanNodeVisitor::visit(BinaryVectorANNS& node) {
     ret_ = json_body;
 }
 
+void
+ShowPlanNodeVisitor::visit(RetrievePlanNode& node) {
+}
+
 }  // namespace milvus::query

internal/core/src/query/visitors/VerifyPlanNodeVisitor.cpp

@@ -108,4 +108,8 @@ VerifyPlanNodeVisitor::visit(BinaryVectorANNS& node) {
     }
 }
 
+void
+VerifyPlanNodeVisitor::visit(RetrievePlanNode& node) {
+}
+
 }  // namespace milvus::query

internal/core/src/segcore/SegmentGrowingImpl.cpp

@@ -437,6 +437,27 @@ SegmentGrowingImpl::Insert(int64_t reserved_offset,
     do_insert(reserved_offset, size, row_ids.data(), timestamps.data(), columns_data);
 }
 
+std::vector<SegOffset>
+SegmentGrowingImpl::search_ids(const boost::dynamic_bitset<>& bitset, Timestamp timestamp) const {
+    std::vector<SegOffset> res_offsets;
+
+    for (int i = 0; i < bitset.size(); i++) {
+        if (bitset[i]) {
+            SegOffset the_offset(-1);
+            auto offset = SegOffset(i);
+            if (record_.timestamps_[offset.get()] < timestamp) {
+                the_offset = std::max(the_offset, offset);
+            }
+
+            if (the_offset == SegOffset(-1)) {
+                continue;
+            }
+            res_offsets.push_back(the_offset);
+        }
+    }
+    return res_offsets;
+}
+
 std::pair<std::unique_ptr<IdArray>, std::vector<SegOffset>>
 SegmentGrowingImpl::search_ids(const IdArray& id_array, Timestamp timestamp) const {
     Assert(id_array.has_int_id());

internal/core/src/segcore/SegmentGrowingImpl.h

@@ -182,6 +182,9 @@ class SegmentGrowingImpl : public SegmentGrowing {
     std::pair<std::unique_ptr<IdArray>, std::vector<SegOffset>>
     search_ids(const IdArray& id_array, Timestamp timestamp) const override;
 
+    std::vector<SegOffset>
+    search_ids(const boost::dynamic_bitset<>& view, Timestamp timestamp) const override;
+
  protected:
     int64_t
     num_chunk() const override;

internal/core/src/segcore/SegmentInterface.cpp

@@ -108,7 +108,7 @@ CreateScalarArrayFrom(const void* data_raw, int64_t count, DataType data_type) {
             break;
         }
         case DataType::INT32: {
-            auto data = reinterpret_cast<const int16_t*>(data_raw);
+            auto data = reinterpret_cast<const int32_t*>(data_raw);
             auto obj = scalar_array->mutable_int_data();
             obj->mutable_data()->Add(data, data + count);
             break;
@@ -192,29 +192,31 @@ SegmentInternalInterface::BulkSubScript(FieldOffset field_offset, const SegOffse
 }
 
 std::unique_ptr<proto::segcore::RetrieveResults>
-SegmentInternalInterface::GetEntityById(const std::vector<FieldOffset>& field_offsets,
+SegmentInternalInterface::Retrieve(const query::RetrievePlan* plan, Timestamp timestamp) const {
-                                        const IdArray& id_array,
+    std::shared_lock lck(mutex_);
-                                        Timestamp timestamp) const {
     auto results = std::make_unique<proto::segcore::RetrieveResults>();
+    query::ExecPlanNodeVisitor visitor(*this, timestamp);
+    auto retrieve_results = visitor.get_retrieve_result(*plan->plan_node_);
+    retrieve_results.segment_ = (void*)this;
 
-    auto [ids_, seg_offsets] = search_ids(id_array, timestamp);
+    for (auto& seg_offset : retrieve_results.result_offsets_) {
-
+        results->add_offset(seg_offset);
-    // std::string dbg_log;
-    // dbg_log += "id_array:" + id_array.DebugString() + "\n";
-    // dbg_log += "ids:" + ids_->DebugString() + "\n";
-    // dbg_log += "segment_info:" + this->debug();
-    // std::cout << dbg_log << std::endl;
-
-    results->set_allocated_ids(ids_.release());
-
-    for (auto& seg_offset : seg_offsets) {
-        results->add_offset(seg_offset.get());
     }
 
     auto fields_data = results->mutable_fields_data();
-    for (auto field_offset : field_offsets) {
+    auto ids = results->mutable_ids();
-        auto col = BulkSubScript(field_offset, seg_offsets.data(), seg_offsets.size());
+    auto pk_offset = plan->schema_.get_primary_key_offset();
-        fields_data->AddAllocated(col.release());
+    for (auto field_offset : plan->field_offsets_) {
+        auto col = BulkSubScript(field_offset, (SegOffset*)retrieve_results.result_offsets_.data(),
+                                 retrieve_results.result_offsets_.size());
+        auto col_data = col.release();
+        fields_data->AddAllocated(col_data);
+        if (pk_offset.has_value() && pk_offset.value() == field_offset) {
+            auto int_ids = ids->mutable_int_id();
+            for (int j = 0; j < col_data->scalars().long_data().data_size(); ++j) {
+                int_ids->add_data(col_data->scalars().long_data().data(j));
+            }
+        }
     }
     return results;
 }

internal/core/src/segcore/SegmentInterface.h

@@ -40,9 +40,7 @@ class SegmentInterface {
     Search(const query::Plan* Plan, const query::PlaceholderGroup& placeholder_group, Timestamp timestamp) const = 0;
 
     virtual std::unique_ptr<proto::segcore::RetrieveResults>
-    GetEntityById(const std::vector<FieldOffset>& field_offsets,
+    Retrieve(const query::RetrievePlan* Plan, Timestamp timestamp) const = 0;
-                  const IdArray& id_array,
-                  Timestamp timestamp) const = 0;
 
     virtual int64_t
     GetMemoryUsageInBytes() const = 0;
@@ -88,9 +86,7 @@ class SegmentInternalInterface : public SegmentInterface {
     FillTargetEntry(const query::Plan* plan, SearchResult& results) const override;
 
     std::unique_ptr<proto::segcore::RetrieveResults>
-    GetEntityById(const std::vector<FieldOffset>& field_offsets,
+    Retrieve(const query::RetrievePlan* plan, Timestamp timestamp) const override;
-                  const IdArray& id_array,
-                  Timestamp timestamp) const override;
 
     virtual std::string
     debug() const = 0;
@@ -123,6 +119,9 @@ class SegmentInternalInterface : public SegmentInterface {
     virtual int64_t
     get_active_count(Timestamp ts) const = 0;
 
+    virtual std::vector<SegOffset>
+    search_ids(const boost::dynamic_bitset<>& view, Timestamp timestamp) const = 0;
+
  protected:
     // internal API: return chunk_data in span
     virtual SpanBase

internal/core/src/segcore/SegmentSealedImpl.cpp

@@ -449,6 +449,17 @@ SegmentSealedImpl::search_ids(const IdArray& id_array, Timestamp timestamp) cons
     return primary_key_index_->do_search_ids(id_array);
 }
 
+std::vector<SegOffset>
+SegmentSealedImpl::search_ids(const boost::dynamic_bitset<>& bitset, Timestamp timestamp) const {
+    std::vector<SegOffset> dst_offset;
+    for (int i = 0; i < bitset.size(); i++) {
+        if (bitset[i]) {
+            dst_offset.emplace_back(SegOffset(i));
+        }
+    }
+    return std::move(dst_offset);
+}
+
 std::string
 SegmentSealedImpl::debug() const {
     std::string log_str;

internal/core/src/segcore/SegmentSealedImpl.h

@@ -126,6 +126,9 @@ class SegmentSealedImpl : public SegmentSealed {
     std::pair<std::unique_ptr<IdArray>, std::vector<SegOffset>>
     search_ids(const IdArray& id_array, Timestamp timestamp) const override;
 
+    std::vector<SegOffset>
+    search_ids(const boost::dynamic_bitset<>& view, Timestamp timestamp) const override;
+
     //    virtual void
     //    build_index_if_primary_key(FieldId field_id);
 

internal/core/src/segcore/plan_c.cpp

@@ -130,23 +130,51 @@ DeletePlaceholderGroup(CPlaceholderGroup cPlaceholder_group) {
     // std::cout << "delete placeholder" << std::endl;
 }
 
-CStatus
+// CStatus
-CreateRetrievePlan(CCollection c_col, CProto retrieve_request, CRetrievePlan* output) {
+// CreateRetrievePlan(CCollection c_col, CProto retrieve_request, CRetrievePlan* output) {
-    auto col = (milvus::segcore::Collection*)c_col;
+//    auto col = (milvus::segcore::Collection*)c_col;
-    try {
+//    try {
-        milvus::proto::segcore::RetrieveRequest request;
+//        milvus::proto::segcore::RetrieveRequest request;
-        request.ParseFromArray(retrieve_request.proto_blob, retrieve_request.proto_size);
+//        request.ParseFromArray(retrieve_request.proto_blob, retrieve_request.proto_size);
-        auto plan = milvus::query::CreateRetrievePlan(*col->get_schema(), std::move(request));
+//        auto plan = milvus::query::CreateRetrievePlan(*col->get_schema(), std::move(request));
-        *output = plan.release();
+//        *output = plan.release();
+//
+//        auto status = CStatus();
+//        status.error_code = Success;
+//        status.error_msg = "";
+//        return status;
+//    } catch (std::exception& e) {
+//        auto status = CStatus();
+//        status.error_code = UnexpectedError;
+//        status.error_msg = strdup(e.what());
+//        return status;
+//    }
+//}
 
+CStatus
+CreateRetrievePlanByExpr(CCollection c_col, const char* serialized_expr_plan, int64_t size, CRetrievePlan* res_plan) {
+    auto col = (milvus::segcore::Collection*)c_col;
+
+    try {
+        auto res = milvus::query::CreateRetrievePlanByExpr(*col->get_schema(), serialized_expr_plan, size);
         auto status = CStatus();
+
         status.error_code = Success;
         status.error_msg = "";
+        auto plan = (CRetrievePlan)res.release();
+        *res_plan = plan;
+        return status;
+    } catch (milvus::SegcoreError& e) {
+        auto status = CStatus();
+        status.error_code = e.get_error_code();
+        status.error_msg = strdup(e.what());
+        *res_plan = nullptr;
         return status;
     } catch (std::exception& e) {
         auto status = CStatus();
         status.error_code = UnexpectedError;
         status.error_msg = strdup(e.what());
+        *res_plan = nullptr;
         return status;
     }
 }

internal/core/src/segcore/plan_c.h

@@ -53,6 +53,9 @@ DeletePlaceholderGroup(CPlaceholderGroup placeholder_group);
 CStatus
 CreateRetrievePlan(CCollection c_col, CProto retrieve_request, CRetrievePlan* output);
 
+CStatus
+CreateRetrievePlanByExpr(CCollection c_col, const char* serialized_expr_plan, int64_t size, CRetrievePlan* res_plan);
+
 void
 DeleteRetrievePlan(CRetrievePlan plan);
 

internal/core/src/segcore/segment_c.cpp

@@ -225,11 +225,11 @@ DropSealedSegmentIndex(CSegmentInterface c_segment, int64_t field_id) {
 }
 
 CProtoResult
-GetEntityByIds(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp) {
+Retrieve(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp) {
     try {
         auto segment = (const milvus::segcore::SegmentInterface*)c_segment;
         auto plan = (const milvus::query::RetrievePlan*)c_plan;
-        auto result = segment->GetEntityById(plan->field_offsets_, *plan->ids_, timestamp);
+        auto result = segment->Retrieve(plan, timestamp);
         return milvus::AllocCProtoResult(*result);
     } catch (std::exception& e) {
         return CProtoResult{milvus::FailureCStatus(UnexpectedError, e.what())};

internal/core/src/segcore/segment_c.h

@@ -25,6 +25,7 @@ extern "C" {
 
 typedef void* CSegmentInterface;
 typedef void* CSearchResult;
+typedef void* CRetrieveResult;
 
 //////////////////////////////    common interfaces    //////////////////////////////
 CSegmentInterface
@@ -44,7 +45,7 @@ Search(CSegmentInterface c_segment,
        CSearchResult* result);
 
 CProtoResult
-GetEntityByIds(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp);
+Retrieve(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp);
 
 int64_t
 GetMemoryUsageInBytes(CSegmentInterface c_segment);

internal/core/unittest/test_get_entity_by_ids.cpp

@@ -12,6 +12,7 @@
 #include <gtest/gtest.h>
 #include "test_utils/DataGen.h"
 #include "segcore/ScalarIndex.h"
+#include "query/ExprImpl.h"
 using namespace milvus;
 using namespace milvus::segcore;
 
@@ -68,17 +69,79 @@ TEST(GetEntityByIds, AUTOID) {
     req_ids_arr->add_data(-1);
 
     std::vector<FieldOffset> target_offsets{FieldOffset(0), FieldOffset(1)};
-    auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
+    //    auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
-    auto ids = retrieve_results->ids().int_id();
+    //    auto ids = retrieve_results->ids().int_id();
+    //    Assert(retrieve_results->fields_data_size() == target_offsets.size());
+    //    FieldOffset field_offset(0);
+    //    auto field0 = retrieve_results->fields_data(0);
+    //    Assert(field0.has_scalars());
+    //    auto field0_data = field0.scalars().long_data();
+    //    for (int i = 0; i < req_size; ++i) {
+    //        auto id = ids.data(i);
+    //        auto index = choose(i);
+    //        ASSERT_EQ(id, dataset.row_ids_[index]);
+    //        auto data = field0_data.data(i);
+    //        ASSERT_EQ(data, i64_col[index]);
+    //    }
+    //
+    //    auto field1 = retrieve_results->fields_data(1);
+    //    Assert(field1.has_vectors());
+    //    auto field1_data = field1.vectors().float_vector();
+    //    ASSERT_EQ(field1_data.data_size(), DIM * req_size);
+    //
+    //    for (int i = 0; i < req_size; ++i) {
+    //        for (int d = 0; d < DIM; ++d) {
+    //            auto index = choose(i);
+    //            auto data = field1_data.data(i * DIM + d);
+    //            auto ref = vf_col[index * DIM + d];
+    //            ASSERT_EQ(data, ref);
+    //        }
+    //    }
+}
+
+TEST(Retrieve, AUTOID) {
+    auto schema = std::make_shared<Schema>();
+    auto fid_64 = schema->AddDebugField("i64", DataType::INT64);
+    auto DIM = 16;
+    auto fid_vec = schema->AddDebugField("vector_64", DataType::VECTOR_FLOAT, DIM, MetricType::METRIC_L2);
+    schema->set_primary_key(FieldOffset(0));
+
+    int64_t N = 100;
+    int64_t req_size = 10;
+    auto choose = [=](int i) { return i * 3 % N; };
+
+    auto dataset = DataGen(schema, N);
+    auto segment = CreateSealedSegment(schema);
+    SealedLoader(dataset, *segment);
+    auto i64_col = dataset.get_col<int64_t>(0);
+
+    auto plan = std::make_unique<query::RetrievePlan>(*schema);
+
+    auto term_expr = std::make_unique<query::TermExprImpl<int64_t>>();
+    term_expr->field_offset_ = FieldOffset(0);
+    term_expr->data_type_ = DataType::INT64;
+    for (int i = 0; i < req_size; ++i) {
+        term_expr->terms_.emplace_back(i64_col[choose(i)]);
+    }
+    plan->plan_node_ = std::make_unique<query::RetrievePlanNode>();
+    plan->plan_node_->predicate_ = std::move(term_expr);
+    std::vector<FieldOffset> target_offsets{FieldOffset(0), FieldOffset(1)};
+    plan->field_offsets_ = target_offsets;
+
+    auto retrieve_results = segment->Retrieve(plan.get(), 100);
     Assert(retrieve_results->fields_data_size() == target_offsets.size());
     FieldOffset field_offset(0);
     auto field0 = retrieve_results->fields_data(0);
     Assert(field0.has_scalars());
     auto field0_data = field0.scalars().long_data();
+
+    for (int i = 0; i < req_size; ++i) {
+        auto index = choose(i);
+        auto data = field0_data.data(i);
+    }
+
     for (int i = 0; i < req_size; ++i) {
-        auto id = ids.data(i);
         auto index = choose(i);
-        ASSERT_EQ(id, dataset.row_ids_[index]);
         auto data = field0_data.data(i);
         ASSERT_EQ(data, i64_col[index]);
     }
@@ -87,15 +150,6 @@ TEST(GetEntityByIds, AUTOID) {
     Assert(field1.has_vectors());
     auto field1_data = field1.vectors().float_vector();
     ASSERT_EQ(field1_data.data_size(), DIM * req_size);
-
-    for (int i = 0; i < req_size; ++i) {
-        for (int d = 0; d < DIM; ++d) {
-            auto index = choose(i);
-            auto data = field1_data.data(i * DIM + d);
-            auto ref = vf_col[index * DIM + d];
-            ASSERT_EQ(data, ref);
-        }
-    }
 }
 
 TEST(GetEntityByIds, PrimaryKey) {
@@ -126,32 +180,32 @@ TEST(GetEntityByIds, PrimaryKey) {
     req_ids_arr->add_data(-1);
 
     std::vector<FieldOffset> target_offsets{FieldOffset(0), FieldOffset(1)};
-    auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
+    //    auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
-    auto ids = retrieve_results->ids().int_id();
+    //    auto ids = retrieve_results->ids().int_id();
-    Assert(retrieve_results->fields_data_size() == target_offsets.size());
+    //    Assert(retrieve_results->fields_data_size() == target_offsets.size());
-    FieldOffset field_offset(0);
+    //    FieldOffset field_offset(0);
-    auto field0 = retrieve_results->fields_data(0);
+    //    auto field0 = retrieve_results->fields_data(0);
-    Assert(field0.has_scalars());
+    //    Assert(field0.has_scalars());
-    auto field0_data = field0.scalars().long_data();
+    //    auto field0_data = field0.scalars().long_data();
-    for (int i = 0; i < req_size; ++i) {
+    //    for (int i = 0; i < req_size; ++i) {
-        auto id = ids.data(i);
+    //        auto id = ids.data(i);
-        auto index = choose(i);
+    //        auto index = choose(i);
-        ASSERT_EQ(id, i64_col[index]);
+    //        ASSERT_EQ(id, i64_col[index]);
-        auto data = field0_data.data(i);
+    //        auto data = field0_data.data(i);
-        ASSERT_EQ(data, i64_col[index]);
+    //        ASSERT_EQ(data, i64_col[index]);
-    }
+    //    }
-
+    //
-    auto field1 = retrieve_results->fields_data(1);
+    //    auto field1 = retrieve_results->fields_data(1);
-    Assert(field1.has_vectors());
+    //    Assert(field1.has_vectors());
-    auto field1_data = field1.vectors().float_vector();
+    //    auto field1_data = field1.vectors().float_vector();
-    ASSERT_EQ(field1_data.data_size(), DIM * req_size);
+    //    ASSERT_EQ(field1_data.data_size(), DIM * req_size);
-
+    //
-    for (int i = 0; i < req_size; ++i) {
+    //    for (int i = 0; i < req_size; ++i) {
-        for (int d = 0; d < DIM; ++d) {
+    //        for (int d = 0; d < DIM; ++d) {
-            auto index = choose(i);
+    //            auto index = choose(i);
-            auto data = field1_data.data(i * DIM + d);
+    //            auto data = field1_data.data(i * DIM + d);
-            auto ref = vf_col[index * DIM + d];
+    //            auto ref = vf_col[index * DIM + d];
-            ASSERT_EQ(data, ref);
+    //            ASSERT_EQ(data, ref);
-        }
+    //        }
-    }
+    //    }
 }

internal/core/unittest/test_utils/DataGen.h

@@ -148,8 +148,11 @@ DataGen(SchemaPtr schema, int64_t N, uint64_t seed = 42) {
                         x = index++;
                     }
                 } else {
+                    int i = 0;
                     for (auto& x : data) {
                         x = er() % (2 * N);
+                        x = i;
+                        i++;
                     }
                 }
                 insert_cols(data);
@@ -191,7 +194,7 @@ DataGen(SchemaPtr schema, int64_t N, uint64_t seed = 42) {
         res.row_ids_.push_back(i);
         res.timestamps_.push_back(i);
     }
-    std::shuffle(res.row_ids_.begin(), res.row_ids_.end(), er);
+    //    std::shuffle(res.row_ids_.begin(), res.row_ids_.end(), er);
     res.generate_rows(N, schema);
     return std::move(res);
 }

internal/proto/internal.proto

@@ -161,7 +161,7 @@ message RetrieveRequest {
   int64 dbID = 3;
   int64 collectionID = 4;
   repeated int64 partitionIDs = 5;
-  schema.IDs ids = 6;
+  bytes serialized_expr_plan = 6;
   repeated int64 output_fields_id = 7;
   uint64 travel_timestamp = 8;
   uint64 guarantee_timestamp = 9;

internal/proto/internalpb/internal.pb.go

@@ -1313,7 +1313,7 @@ type RetrieveRequest struct {
 	DbID                 int64             `protobuf:"varint,3,opt,name=dbID,proto3" json:"dbID,omitempty"`
 	CollectionID         int64             `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
 	PartitionIDs         []int64           `protobuf:"varint,5,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
-	Ids                  *schemapb.IDs     `protobuf:"bytes,6,opt,name=ids,proto3" json:"ids,omitempty"`
+	SerializedExprPlan   []byte            `protobuf:"bytes,6,opt,name=serialized_expr_plan,json=serializedExprPlan,proto3" json:"serialized_expr_plan,omitempty"`
 	OutputFieldsId       []int64           `protobuf:"varint,7,rep,packed,name=output_fields_id,json=outputFieldsId,proto3" json:"output_fields_id,omitempty"`
 	TravelTimestamp      uint64            `protobuf:"varint,8,opt,name=travel_timestamp,json=travelTimestamp,proto3" json:"travel_timestamp,omitempty"`
 	GuaranteeTimestamp   uint64            `protobuf:"varint,9,opt,name=guarantee_timestamp,json=guaranteeTimestamp,proto3" json:"guarantee_timestamp,omitempty"`
@@ -1382,9 +1382,9 @@ func (m *RetrieveRequest) GetPartitionIDs() []int64 {
 	return nil
 }
 
-func (m *RetrieveRequest) GetIds() *schemapb.IDs {
+func (m *RetrieveRequest) GetSerializedExprPlan() []byte {
 	if m != nil {
-		return m.Ids
+		return m.SerializedExprPlan
 	}
 	return nil
 }
@@ -2220,128 +2220,128 @@ func init() {
 func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
 
 var fileDescriptor_41f4a519b878ee3b = []byte{
-	// 1959 bytes of a gzipped FileDescriptorProto
+	// 1958 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x5b, 0x6f, 0x24, 0x47,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x5b, 0x6f, 0x1c, 0x49,
-	0x15, 0xa6, 0xa7, 0xc7, 0x9e, 0x99, 0x33, 0x63, 0x7b, 0xb6, 0xec, 0x6c, 0xda, 0xde, 0xcd, 0xae,
+	0x15, 0xa6, 0xa7, 0xc7, 0x9e, 0x99, 0xd3, 0x63, 0x67, 0x52, 0xf1, 0x66, 0xdb, 0x4e, 0x36, 0xf1,
-	0xd3, 0x09, 0x60, 0xb2, 0x62, 0xbd, 0x38, 0x40, 0x22, 0x84, 0xd8, 0xc4, 0x9e, 0xb0, 0x8c, 0x36,
+	0xf6, 0x2e, 0x60, 0x36, 0x22, 0x0e, 0x5e, 0x60, 0x57, 0x08, 0x91, 0x5d, 0x7b, 0x96, 0x30, 0xca,
-	0x36, 0xa6, 0xbd, 0x89, 0x04, 0x2f, 0xad, 0x9a, 0xee, 0xf2, 0xb8, 0xd9, 0xbe, 0xa5, 0xab, 0xda,
+	0xda, 0x98, 0x76, 0x76, 0x25, 0x78, 0x69, 0xd5, 0x74, 0x97, 0xc7, 0x4d, 0xfa, 0xb6, 0x5d, 0xd5,
-	0xbb, 0x93, 0x27, 0x1e, 0x78, 0x02, 0x81, 0x04, 0x12, 0x7f, 0x83, 0x57, 0x9e, 0xb8, 0x88, 0x27,
+	0x4e, 0x66, 0x9f, 0x10, 0xe2, 0x09, 0x04, 0x12, 0x48, 0xfc, 0x0d, 0x5e, 0x79, 0xe2, 0x22, 0x9e,
-	0x24, 0x7e, 0x01, 0xff, 0x04, 0x21, 0x1e, 0x50, 0x9d, 0xaa, 0xbe, 0xcc, 0x78, 0x6c, 0x66, 0xbd,
+	0x90, 0xf8, 0x05, 0xfc, 0x13, 0xc4, 0x13, 0xaa, 0x53, 0xd5, 0x97, 0x19, 0x8f, 0x8d, 0xe3, 0x08,
-	0x02, 0x82, 0xe0, 0x6d, 0xea, 0x3b, 0xa7, 0x2e, 0xe7, 0x3b, 0x97, 0x3a, 0x5d, 0x03, 0xab, 0x41,
+	0x58, 0x04, 0x6f, 0x5d, 0xdf, 0x39, 0x75, 0x39, 0xdf, 0xb9, 0xd4, 0x99, 0x1a, 0x58, 0x0d, 0x13,
-	0x2c, 0x58, 0x16, 0xd3, 0xf0, 0x7e, 0x9a, 0x25, 0x22, 0x21, 0xaf, 0x44, 0x41, 0x78, 0x9e, 0x73,
+	0xc1, 0xf2, 0x84, 0x46, 0xf7, 0xb3, 0x3c, 0x15, 0x29, 0x79, 0x25, 0x0e, 0xa3, 0xd3, 0x82, 0xab,
-	0x35, 0xba, 0x5f, 0x08, 0xb7, 0x7a, 0x5e, 0x12, 0x45, 0x49, 0xac, 0xe0, 0xad, 0x1e, 0xf7, 0xce,
+	0xd1, 0xfd, 0x52, 0xb8, 0xd1, 0xf7, 0xd3, 0x38, 0x4e, 0x13, 0x05, 0x6f, 0xf4, 0xb9, 0x7f, 0xc2,
-	0x58, 0x44, 0xd5, 0xc8, 0xfe, 0x9d, 0x01, 0x2b, 0x07, 0x49, 0x94, 0x26, 0x31, 0x8b, 0xc5, 0x30,
+	0x62, 0xaa, 0x46, 0xce, 0xef, 0x0d, 0x58, 0xd9, 0x4b, 0xe3, 0x2c, 0x4d, 0x58, 0x22, 0x46, 0xc9,
-	0x3e, 0x4d, 0xc8, 0x4d, 0x58, 0x8e, 0x13, 0x9f, 0x0d, 0x07, 0x96, 0xb1, 0x6d, 0xec, 0x98, 0x8e,
+	0x71, 0x4a, 0x6e, 0xc2, 0x72, 0x92, 0x06, 0x6c, 0x34, 0xb4, 0x8d, 0x4d, 0x63, 0xcb, 0x74, 0xf5,
-	0x1e, 0x11, 0x02, 0xcd, 0x2c, 0x09, 0x99, 0xd5, 0xd8, 0x36, 0x76, 0x3a, 0x0e, 0xfe, 0x26, 0x0f,
+	0x88, 0x10, 0x68, 0xe7, 0x69, 0xc4, 0xec, 0xd6, 0xa6, 0xb1, 0xd5, 0x73, 0xf1, 0x9b, 0x3c, 0x04,
-	0x01, 0xb8, 0xa0, 0x82, 0xb9, 0x5e, 0xe2, 0x33, 0xcb, 0xdc, 0x36, 0x76, 0x56, 0xf7, 0xb6, 0xef,
+	0xe0, 0x82, 0x0a, 0xe6, 0xf9, 0x69, 0xc0, 0x6c, 0x73, 0xd3, 0xd8, 0x5a, 0xdd, 0xd9, 0xbc, 0xbf,
-	0xcf, 0x3d, 0xc5, 0xfd, 0x13, 0xa9, 0x78, 0x90, 0xf8, 0xcc, 0xe9, 0xf0, 0xe2, 0x27, 0x79, 0x0f,
+	0xf0, 0x14, 0xf7, 0x8f, 0xa4, 0xe2, 0x5e, 0x1a, 0x30, 0xb7, 0xc7, 0xcb, 0x4f, 0xf2, 0x1e, 0x00,
-	0x80, 0x3d, 0x17, 0x19, 0x75, 0x83, 0xf8, 0x34, 0xb1, 0x9a, 0xdb, 0xe6, 0x4e, 0x77, 0xef, 0xf5,
+	0x7b, 0x2e, 0x72, 0xea, 0x85, 0xc9, 0x71, 0x6a, 0xb7, 0x37, 0xcd, 0x2d, 0x6b, 0xe7, 0xf5, 0xd9,
-	0xe9, 0x05, 0xf4, 0xe1, 0x1f, 0xb3, 0xc9, 0xc7, 0x34, 0xcc, 0xd9, 0x31, 0x0d, 0x32, 0xa7, 0x83,
+	0x05, 0xf4, 0xe1, 0x1f, 0xb3, 0xe9, 0xc7, 0x34, 0x2a, 0xd8, 0x21, 0x0d, 0x73, 0xb7, 0x87, 0x93,
-	0x93, 0xe4, 0x71, 0xed, 0xbf, 0x18, 0xb0, 0x56, 0x1a, 0x80, 0x7b, 0x70, 0xf2, 0x0d, 0x58, 0xc2,
+	0xe4, 0x71, 0x9d, 0xbf, 0x1a, 0x70, 0xad, 0x32, 0x00, 0xf7, 0xe0, 0xe4, 0x1b, 0xb0, 0x84, 0x5b,
-	0x2d, 0xd0, 0x82, 0xee, 0xde, 0x9b, 0x97, 0x9c, 0x68, 0xca, 0x6e, 0x47, 0x4d, 0x21, 0x1f, 0xc1,
+	0xa0, 0x05, 0xd6, 0xce, 0x9b, 0xe7, 0x9c, 0x68, 0xc6, 0x6e, 0x57, 0x4d, 0x21, 0x1f, 0xc1, 0x0d,
-	0x3a, 0xcf, 0x47, 0x5e, 0x21, 0x72, 0x11, 0xe5, 0x56, 0x03, 0x8f, 0xb6, 0xd8, 0x4a, 0xa4, 0xbe,
+	0x5e, 0x8c, 0xfd, 0x52, 0xe4, 0x21, 0xca, 0xed, 0x16, 0x1e, 0xed, 0x72, 0x2b, 0x91, 0xe6, 0x02,
-	0x80, 0x3e, 0xd2, 0xdb, 0xb0, 0x2c, 0x57, 0xca, 0x39, 0xb2, 0xd4, 0xdd, 0xbb, 0x35, 0xd7, 0xc8,
+	0xfa, 0x48, 0x6f, 0xc3, 0xb2, 0x5c, 0xa9, 0xe0, 0xc8, 0x92, 0xb5, 0x73, 0x6b, 0xa1, 0x91, 0x47,
-	0x13, 0x54, 0x71, 0xb4, 0xaa, 0x7d, 0x0b, 0x36, 0x1f, 0x31, 0x31, 0x63, 0x9d, 0xc3, 0x3e, 0xc9,
+	0xa8, 0xe2, 0x6a, 0x55, 0xe7, 0x16, 0xac, 0x3f, 0x62, 0x62, 0xce, 0x3a, 0x97, 0x7d, 0x52, 0x30,
-	0x19, 0x17, 0x5a, 0xf8, 0x24, 0x88, 0xd8, 0x93, 0xc0, 0x7b, 0x7a, 0x70, 0x46, 0xe3, 0x98, 0x85,
+	0x2e, 0xb4, 0xf0, 0x49, 0x18, 0xb3, 0x27, 0xa1, 0xff, 0x74, 0xef, 0x84, 0x26, 0x09, 0x8b, 0x4a,
-	0x85, 0xf0, 0x35, 0xb8, 0xf5, 0x88, 0xe1, 0x84, 0x80, 0x8b, 0xc0, 0xe3, 0x33, 0xe2, 0x57, 0x60,
+	0xe1, 0x6b, 0x70, 0xeb, 0x11, 0xc3, 0x09, 0x21, 0x17, 0xa1, 0xcf, 0xe7, 0xc4, 0xaf, 0xc0, 0x8d,
-	0xfd, 0x11, 0x13, 0x03, 0x7f, 0x06, 0xfe, 0x18, 0xda, 0x47, 0xd2, 0xd9, 0x32, 0x0c, 0xbe, 0x0e,
+	0x47, 0x4c, 0x0c, 0x83, 0x39, 0xf8, 0x63, 0xe8, 0x1e, 0x48, 0x67, 0xcb, 0x30, 0xf8, 0x3a, 0x74,
-	0x2d, 0xea, 0xfb, 0x19, 0xe3, 0x5c, 0xb3, 0x78, 0x7b, 0xee, 0x89, 0xdf, 0x57, 0x3a, 0x4e, 0xa1,
+	0x68, 0x10, 0xe4, 0x8c, 0x73, 0xcd, 0xe2, 0xed, 0x85, 0x27, 0x7e, 0x5f, 0xe9, 0xb8, 0xa5, 0xf2,
-	0x3c, 0x2f, 0x4c, 0xec, 0x1f, 0x02, 0x0c, 0xe3, 0x40, 0x1c, 0xd3, 0x8c, 0x46, 0xfc, 0xd2, 0x00,
+	0xa2, 0x30, 0x71, 0x7e, 0x08, 0x30, 0x4a, 0x42, 0x71, 0x48, 0x73, 0x1a, 0xf3, 0x73, 0x03, 0x6c,
-	0x1b, 0x40, 0x8f, 0x0b, 0x9a, 0x09, 0x37, 0x45, 0x3d, 0x4d, 0xf9, 0x02, 0xd1, 0xd0, 0xc5, 0x69,
+	0x08, 0x7d, 0x2e, 0x68, 0x2e, 0xbc, 0x0c, 0xf5, 0x34, 0xe5, 0x97, 0x88, 0x06, 0x0b, 0xa7, 0xa9,
-	0x6a, 0x75, 0xfb, 0xfb, 0x00, 0x27, 0x22, 0x0b, 0xe2, 0xf1, 0x87, 0x01, 0x17, 0x72, 0xaf, 0x73,
+	0xd5, 0x9d, 0xef, 0x03, 0x1c, 0x89, 0x3c, 0x4c, 0x26, 0x1f, 0x86, 0x5c, 0xc8, 0xbd, 0x4e, 0xa5,
-	0xa9, 0x27, 0x8d, 0x30, 0x77, 0x3a, 0x8e, 0x1e, 0xd5, 0xdc, 0xd1, 0x58, 0xdc, 0x1d, 0x0f, 0xa1,
+	0x9e, 0x34, 0xc2, 0xdc, 0xea, 0xb9, 0x7a, 0xd4, 0x70, 0x47, 0xeb, 0xf2, 0xee, 0x78, 0x08, 0x56,
-	0x5b, 0xd0, 0x7d, 0xc8, 0xc7, 0xe4, 0x01, 0x34, 0x47, 0x94, 0xb3, 0x2b, 0xe9, 0x39, 0xe4, 0xe3,
+	0x49, 0xf7, 0x3e, 0x9f, 0x90, 0x07, 0xd0, 0x1e, 0x53, 0xce, 0x2e, 0xa4, 0x67, 0x9f, 0x4f, 0x76,
-	0x7d, 0xca, 0x99, 0x83, 0x9a, 0xf6, 0x4f, 0x4c, 0x78, 0xf5, 0x20, 0x63, 0x18, 0xfc, 0x61, 0xc8,
+	0x29, 0x67, 0x2e, 0x6a, 0x3a, 0x3f, 0x35, 0xe1, 0xd5, 0xbd, 0x9c, 0x61, 0xf0, 0x47, 0x11, 0xf3,
-	0x3c, 0x11, 0x24, 0xb1, 0xe6, 0xfe, 0xc5, 0x57, 0x23, 0xaf, 0x42, 0xcb, 0x1f, 0xb9, 0x31, 0x8d,
+	0x45, 0x98, 0x26, 0x9a, 0xfb, 0x17, 0x5f, 0x8d, 0xbc, 0x0a, 0x9d, 0x60, 0xec, 0x25, 0x34, 0x2e,
-	0x0a, 0xb2, 0x97, 0xfd, 0xd1, 0x11, 0x8d, 0x18, 0xf9, 0x02, 0xac, 0x7a, 0xe5, 0xfa, 0x12, 0xc1,
+	0xc9, 0x5e, 0x0e, 0xc6, 0x07, 0x34, 0x66, 0xe4, 0x0b, 0xb0, 0xea, 0x57, 0xeb, 0x4b, 0x04, 0x63,
-	0x98, 0xeb, 0x38, 0x33, 0x28, 0x79, 0x13, 0x56, 0x52, 0x9a, 0x89, 0xa0, 0x54, 0x6b, 0xa2, 0xda,
+	0xae, 0xe7, 0xce, 0xa1, 0xe4, 0x4d, 0x58, 0xc9, 0x68, 0x2e, 0xc2, 0x4a, 0xad, 0x8d, 0x6a, 0xb3,
-	0x34, 0x28, 0x1d, 0xea, 0x8f, 0x86, 0x03, 0x6b, 0x09, 0x9d, 0x85, 0xbf, 0x89, 0x0d, 0xbd, 0x6a,
+	0xa0, 0x74, 0x68, 0x30, 0x1e, 0x0d, 0xed, 0x25, 0x74, 0x16, 0x7e, 0x13, 0x07, 0xfa, 0xf5, 0x5a,
-	0xad, 0xe1, 0xc0, 0x5a, 0x46, 0xd9, 0x14, 0x46, 0xb6, 0xa1, 0x5b, 0x2e, 0x34, 0x1c, 0x58, 0x2d,
+	0xa3, 0xa1, 0xbd, 0x8c, 0xb2, 0x19, 0x8c, 0x6c, 0x82, 0x55, 0x2d, 0x34, 0x1a, 0xda, 0x1d, 0x54,
-	0x54, 0xa9, 0x43, 0xd2, 0x39, 0xaa, 0x16, 0x59, 0xed, 0x6d, 0x63, 0xa7, 0xe7, 0xe8, 0x11, 0x79,
+	0x69, 0x42, 0xd2, 0x39, 0xaa, 0x16, 0xd9, 0xdd, 0x4d, 0x63, 0xab, 0xef, 0xea, 0x11, 0x79, 0x00,
-	0x00, 0xeb, 0xe7, 0x41, 0x26, 0x72, 0x1a, 0xea, 0xf8, 0x94, 0xe7, 0xe0, 0x56, 0x07, 0x3d, 0x38,
+	0x37, 0x4e, 0xc3, 0x5c, 0x14, 0x34, 0xd2, 0xf1, 0x29, 0xcf, 0xc1, 0xed, 0x1e, 0x7a, 0x70, 0x91,
-	0x4f, 0x44, 0xf6, 0x60, 0x23, 0x3d, 0x9b, 0xf0, 0xc0, 0x9b, 0x99, 0x02, 0x38, 0x65, 0xae, 0xcc,
+	0x88, 0xec, 0xc0, 0x5a, 0x76, 0x32, 0xe5, 0xa1, 0x3f, 0x37, 0x05, 0x70, 0xca, 0x42, 0x99, 0xf3,
-	0xfe, 0xa3, 0x01, 0xaf, 0x0c, 0xb2, 0x24, 0xfd, 0x4c, 0xb8, 0xa2, 0x20, 0xb9, 0x79, 0x05, 0xc9,
+	0x27, 0x03, 0x5e, 0x19, 0xe6, 0x69, 0xf6, 0x99, 0x70, 0x45, 0x49, 0x72, 0xfb, 0x02, 0x92, 0x97,
-	0x4b, 0x17, 0x49, 0xb6, 0x7f, 0xd6, 0x80, 0x9b, 0x2a, 0xa2, 0x8e, 0x0b, 0x62, 0xff, 0x05, 0x56,
+	0xce, 0x92, 0xec, 0xfc, 0xbc, 0x05, 0x37, 0x55, 0x44, 0x1d, 0x96, 0xc4, 0xfe, 0x0b, 0xac, 0xf8,
-	0x7c, 0x11, 0xd6, 0xaa, 0x5d, 0x95, 0xc2, 0x7c, 0x33, 0x3e, 0x0f, 0xab, 0xa5, 0x83, 0x95, 0xde,
+	0x22, 0x5c, 0xab, 0x77, 0x55, 0x0a, 0x8b, 0xcd, 0xf8, 0x3c, 0xac, 0x56, 0x0e, 0x56, 0x7a, 0xff,
-	0xbf, 0x37, 0xa4, 0xec, 0x9f, 0x36, 0x60, 0x43, 0x3a, 0xf5, 0xff, 0x6c, 0x48, 0x36, 0x7e, 0xdf,
+	0xde, 0x90, 0x72, 0x7e, 0xd6, 0x82, 0x35, 0xe9, 0xd4, 0xff, 0xb3, 0x21, 0xd9, 0xf8, 0x43, 0x0b,
-	0x00, 0xa2, 0xa2, 0x63, 0x18, 0xfb, 0xec, 0xf9, 0x7f, 0x92, 0x8b, 0xd7, 0x00, 0x4e, 0x03, 0x16,
+	0x88, 0x8a, 0x8e, 0x51, 0x12, 0xb0, 0xe7, 0xff, 0x49, 0x2e, 0x5e, 0x03, 0x38, 0x0e, 0x59, 0x14,
-	0xfa, 0x75, 0x1e, 0x3a, 0x88, 0xbc, 0x14, 0x07, 0x16, 0xb4, 0x70, 0x91, 0xd2, 0xfe, 0x62, 0x28,
+	0x34, 0x79, 0xe8, 0x21, 0xf2, 0x52, 0x1c, 0xd8, 0xd0, 0xc1, 0x45, 0x2a, 0xfb, 0xcb, 0xa1, 0xbc,
-	0x6f, 0x13, 0xd5, 0x59, 0xe8, 0xdb, 0xa4, 0xbd, 0xf0, 0x6d, 0x82, 0xd3, 0xf4, 0x6d, 0xf2, 0x6b,
+	0x4d, 0x54, 0x67, 0xa1, 0x6f, 0x93, 0xee, 0xa5, 0x6f, 0x13, 0x9c, 0xa6, 0x6f, 0x93, 0xdf, 0x98,
-	0x13, 0x56, 0x86, 0x31, 0x67, 0x99, 0xf8, 0x5f, 0x0e, 0x24, 0x72, 0x1b, 0x3a, 0x9c, 0x8d, 0x23,
+	0xb0, 0x32, 0x4a, 0x38, 0xcb, 0xc5, 0xff, 0x72, 0x20, 0x91, 0xdb, 0xd0, 0xe3, 0x6c, 0x12, 0xcb,
-	0xd9, 0xe0, 0x0c, 0xb0, 0x58, 0x9b, 0x4e, 0x05, 0x48, 0xa9, 0xa7, 0x2a, 0xeb, 0x70, 0x60, 0x75,
+	0x06, 0x67, 0x88, 0xc5, 0xda, 0x74, 0x6b, 0x40, 0x4a, 0x7d, 0x55, 0x59, 0x47, 0x43, 0xbb, 0xa7,
-	0x94, 0x6b, 0x4b, 0x80, 0xdc, 0x01, 0x10, 0x41, 0xc4, 0xb8, 0xa0, 0x51, 0xaa, 0x2a, 0x72, 0xd3,
+	0x5c, 0x5b, 0x01, 0xe4, 0x0e, 0x80, 0x08, 0x63, 0xc6, 0x05, 0x8d, 0x33, 0x55, 0x91, 0xdb, 0x6e,
-	0xa9, 0x21, 0xf2, 0x16, 0xc8, 0x92, 0x67, 0xc3, 0x01, 0xb7, 0xba, 0xdb, 0xa6, 0x6c, 0x07, 0xd4,
+	0x03, 0x91, 0xb7, 0x40, 0x9e, 0x3e, 0x1b, 0x0d, 0xb9, 0x6d, 0x6d, 0x9a, 0xb2, 0x1d, 0x50, 0x23,
-	0x88, 0x7c, 0x15, 0xda, 0x59, 0xf2, 0xcc, 0xf5, 0xa9, 0xa0, 0x56, 0x0f, 0x9d, 0xb7, 0x39, 0x97,
+	0xf2, 0x55, 0xe8, 0xe6, 0xe9, 0x33, 0x2f, 0xa0, 0x82, 0xda, 0x7d, 0x74, 0xde, 0xfa, 0x42, 0xb2,
-	0xec, 0xfd, 0x30, 0x19, 0x39, 0xad, 0x2c, 0x79, 0x36, 0xa0, 0x82, 0xda, 0x7f, 0x35, 0x61, 0xe5,
+	0x77, 0xa3, 0x74, 0xec, 0x76, 0xf2, 0xf4, 0xd9, 0x90, 0x0a, 0xea, 0xfc, 0xcd, 0x84, 0x95, 0x23,
-	0x84, 0xd1, 0xcc, 0x3b, 0xbb, 0xbe, 0xc3, 0xbe, 0x04, 0xfd, 0x8c, 0xf1, 0x3c, 0x14, 0x6e, 0x65,
+	0x46, 0x73, 0xff, 0xe4, 0xea, 0x0e, 0xfb, 0x12, 0x0c, 0x72, 0xc6, 0x8b, 0x48, 0x78, 0xb5, 0x59,
-	0x96, 0xf2, 0xdc, 0x9a, 0xc2, 0x0f, 0x4a, 0xe3, 0x0a, 0xca, 0xcd, 0x2b, 0x28, 0x6f, 0xce, 0xa1,
+	0xca, 0x73, 0xd7, 0x14, 0xbe, 0x57, 0x19, 0x57, 0x52, 0x6e, 0x5e, 0x40, 0x79, 0x7b, 0x01, 0xe5,
-	0xdc, 0x86, 0x5e, 0x8d, 0x5f, 0x6e, 0x2d, 0xa1, 0xe9, 0x53, 0x18, 0xe9, 0x83, 0xe9, 0xf3, 0x10,
+	0x0e, 0xf4, 0x1b, 0xfc, 0x72, 0x7b, 0x09, 0x4d, 0x9f, 0xc1, 0xc8, 0x00, 0xcc, 0x80, 0x47, 0xe8,
-	0x3d, 0xd6, 0x71, 0xe4, 0x4f, 0x72, 0x0f, 0x6e, 0xa4, 0x21, 0xf5, 0xd8, 0x59, 0x12, 0xfa, 0x2c,
+	0xb1, 0x9e, 0x2b, 0x3f, 0xc9, 0x3d, 0xb8, 0x9e, 0x45, 0xd4, 0x67, 0x27, 0x69, 0x14, 0xb0, 0xdc,
-	0x73, 0xc7, 0x59, 0x92, 0xa7, 0xe8, 0xae, 0x9e, 0xd3, 0xaf, 0x09, 0x1e, 0x49, 0x9c, 0xbc, 0x03,
+	0x9b, 0xe4, 0x69, 0x91, 0xa1, 0xbb, 0xfa, 0xee, 0xa0, 0x21, 0x78, 0x24, 0x71, 0xf2, 0x0e, 0x74,
-	0x6d, 0x9f, 0x87, 0xae, 0x98, 0xa4, 0x0c, 0x5d, 0xb6, 0x7a, 0x89, 0xed, 0x03, 0x1e, 0x3e, 0x99,
+	0x03, 0x1e, 0x79, 0x62, 0x9a, 0x31, 0x74, 0xd9, 0xea, 0x39, 0xb6, 0x0f, 0x79, 0xf4, 0x64, 0x9a,
-	0xa4, 0xcc, 0x69, 0xf9, 0xea, 0x07, 0x79, 0x00, 0x1b, 0x9c, 0x65, 0x01, 0x0d, 0x83, 0x4f, 0x99,
+	0x31, 0xb7, 0x13, 0xa8, 0x0f, 0xf2, 0x00, 0xd6, 0x38, 0xcb, 0x43, 0x1a, 0x85, 0x9f, 0xb2, 0xc0,
-	0xef, 0xb2, 0xe7, 0x69, 0xe6, 0xa6, 0x21, 0x8d, 0xd1, 0xb3, 0x3d, 0x87, 0x54, 0xb2, 0x0f, 0x9e,
+	0x63, 0xcf, 0xb3, 0xdc, 0xcb, 0x22, 0x9a, 0xa0, 0x67, 0xfb, 0x2e, 0xa9, 0x65, 0x1f, 0x3c, 0xcf,
-	0xa7, 0xd9, 0x71, 0x48, 0x63, 0xb2, 0x03, 0xfd, 0x24, 0x17, 0x69, 0x2e, 0x5c, 0xcc, 0x3e, 0xee,
+	0xf2, 0xc3, 0x88, 0x26, 0x64, 0x0b, 0x06, 0x69, 0x21, 0xb2, 0x42, 0x78, 0x98, 0x7d, 0xdc, 0x0b,
-	0x06, 0x3e, 0x3a, 0xda, 0x74, 0x56, 0x15, 0xfe, 0x6d, 0x84, 0x87, 0xbe, 0xa4, 0x56, 0x64, 0xf4,
+	0x03, 0x74, 0xb4, 0xe9, 0xae, 0x2a, 0xfc, 0xdb, 0x08, 0x8f, 0x02, 0x49, 0xad, 0xc8, 0xe9, 0x29,
-	0x9c, 0x85, 0x6e, 0x19, 0x01, 0x56, 0x77, 0xdb, 0xd8, 0x69, 0x3a, 0x6b, 0x0a, 0x7f, 0x52, 0xc0,
+	0x8b, 0xbc, 0x2a, 0x02, 0x6c, 0x6b, 0xd3, 0xd8, 0x6a, 0xbb, 0xd7, 0x14, 0xfe, 0xa4, 0x84, 0xc9,
-	0x64, 0x17, 0xd6, 0xc7, 0x39, 0xcd, 0x68, 0x2c, 0x18, 0xab, 0x69, 0xf7, 0x50, 0x9b, 0x94, 0xa2,
+	0x36, 0xdc, 0x98, 0x14, 0x34, 0xa7, 0x89, 0x60, 0xac, 0xa1, 0xdd, 0x47, 0x6d, 0x52, 0x89, 0xaa,
-	0x72, 0x82, 0xfd, 0x8b, 0x66, 0xe5, 0x7a, 0xe9, 0x25, 0x7e, 0x0d, 0xd7, 0x5f, 0xa7, 0x2f, 0x9c,
+	0x09, 0xce, 0x2f, 0xdb, 0xb5, 0xeb, 0xa5, 0x97, 0xf8, 0x15, 0x5c, 0x7f, 0x95, 0xbe, 0x70, 0x61,
-	0x1b, 0x2f, 0xe6, 0xfc, 0x78, 0xb9, 0x0b, 0xdd, 0x88, 0x89, 0x2c, 0xf0, 0x94, 0x5f, 0x54, 0x1a,
+	0xbc, 0x98, 0x8b, 0xe3, 0xe5, 0x2e, 0x58, 0x31, 0x13, 0x79, 0xe8, 0x2b, 0xbf, 0xa8, 0x34, 0x06,
-	0x83, 0x82, 0x90, 0xfc, 0xbb, 0xd0, 0x8d, 0xf3, 0xc8, 0xfd, 0x24, 0x67, 0x59, 0xc0, 0xb8, 0x4e,
+	0x05, 0x21, 0xf9, 0x77, 0xc1, 0x4a, 0x8a, 0xd8, 0xfb, 0xa4, 0x60, 0x79, 0xc8, 0xb8, 0x4e, 0x65,
-	0x65, 0x88, 0xf3, 0xe8, 0x7b, 0x0a, 0x21, 0xeb, 0xb0, 0x24, 0x92, 0xd4, 0x7d, 0xaa, 0x33, 0xb9,
+	0x48, 0x8a, 0xf8, 0x7b, 0x0a, 0x21, 0x37, 0x60, 0x49, 0xa4, 0x99, 0xf7, 0x54, 0x67, 0x72, 0x5b,
-	0x29, 0x92, 0xf4, 0x31, 0xf9, 0x26, 0x6c, 0x71, 0x46, 0x43, 0xe6, 0xbb, 0x65, 0x56, 0x72, 0x97,
+	0xa4, 0xd9, 0x63, 0xf2, 0x4d, 0xd8, 0xe0, 0x8c, 0x46, 0x2c, 0xf0, 0xaa, 0xac, 0xe4, 0x1e, 0x47,
-	0x23, 0x17, 0xcc, 0xb7, 0x5a, 0xe8, 0x0a, 0x4b, 0x69, 0x9c, 0x94, 0x0a, 0x27, 0x5a, 0x2e, 0x99,
+	0x2e, 0x58, 0x60, 0x77, 0xd0, 0x15, 0xb6, 0xd2, 0x38, 0xaa, 0x14, 0x8e, 0xb4, 0x5c, 0x32, 0x5d,
-	0x2e, 0x0f, 0x5e, 0x9b, 0xd6, 0xc6, 0xe6, 0x89, 0x54, 0xa2, 0x72, 0xc2, 0xbb, 0x60, 0x8d, 0xc3,
+	0x1d, 0xbc, 0x31, 0xad, 0x8b, 0xcd, 0x13, 0xa9, 0x45, 0xd5, 0x84, 0x77, 0xc1, 0x9e, 0x44, 0xe9,
-	0x64, 0x44, 0x43, 0xf7, 0xc2, 0xae, 0xd8, 0xa5, 0x99, 0xce, 0x4d, 0x25, 0x3f, 0x99, 0xd9, 0x52,
+	0x98, 0x46, 0xde, 0x99, 0x5d, 0xb1, 0x4b, 0x33, 0xdd, 0x9b, 0x4a, 0x7e, 0x34, 0xb7, 0xa5, 0x34,
-	0x9a, 0xc7, 0xc3, 0xc0, 0x63, 0xbe, 0x3b, 0x0a, 0x93, 0x91, 0x05, 0x18, 0x52, 0xa0, 0x20, 0x99,
+	0x8f, 0x47, 0xa1, 0xcf, 0x02, 0x6f, 0x1c, 0xa5, 0x63, 0x1b, 0x30, 0xa4, 0x40, 0x41, 0x32, 0x91,
-	0xc8, 0x32, 0x94, 0xb4, 0x82, 0xa4, 0xc1, 0x4b, 0xf2, 0x58, 0x60, 0x80, 0x98, 0xce, 0xaa, 0xc2,
+	0x65, 0x28, 0x69, 0x05, 0x49, 0x83, 0x9f, 0x16, 0x89, 0xc0, 0x00, 0x31, 0xdd, 0x55, 0x85, 0x1f,
-	0x8f, 0xf2, 0xe8, 0x40, 0xa2, 0xe4, 0x0d, 0x58, 0xd1, 0x9a, 0xc9, 0xe9, 0x29, 0x67, 0x02, 0x23,
+	0x14, 0xf1, 0x9e, 0x44, 0xc9, 0x1b, 0xb0, 0xa2, 0x35, 0xd3, 0xe3, 0x63, 0xce, 0x04, 0x46, 0x86,
-	0xc3, 0x74, 0x7a, 0x0a, 0xfc, 0x2e, 0x62, 0xf6, 0xdf, 0x1b, 0xb0, 0xe6, 0x48, 0x76, 0xd9, 0x39,
+	0xe9, 0xf6, 0x15, 0xf8, 0x5d, 0xc4, 0x9c, 0x1f, 0x9b, 0x70, 0xcd, 0x95, 0xec, 0xb2, 0x53, 0xf6,
-	0xfb, 0xaf, 0x2f, 0x08, 0x6f, 0x81, 0x19, 0xf8, 0x1c, 0x1d, 0xdf, 0xdd, 0xb3, 0xa6, 0xcf, 0xad,
+	0x5f, 0x5f, 0x10, 0xce, 0x4b, 0xcc, 0xe5, 0x17, 0x4a, 0xcc, 0xce, 0xa5, 0x13, 0xb3, 0xfb, 0x42,
-	0x3f, 0xea, 0x87, 0x03, 0xee, 0x48, 0xa5, 0xb9, 0x29, 0xd9, 0x5a, 0x38, 0x25, 0xdb, 0x2f, 0x94,
+	0x89, 0xd9, 0x3b, 0x37, 0x31, 0x7f, 0x37, 0xe3, 0x84, 0xcf, 0x6a, 0x6a, 0xbe, 0x05, 0x66, 0x18,
-	0x92, 0x9d, 0x4b, 0x53, 0xf2, 0xb7, 0x66, 0x9d, 0xfe, 0xcf, 0x6a, 0x52, 0x6a, 0x5e, 0x9b, 0x8b,
+	0x70, 0x74, 0x8e, 0xb5, 0x63, 0xcf, 0x2e, 0xae, 0x9f, 0x4c, 0x46, 0x43, 0xee, 0x4a, 0x25, 0xf2,
-	0xf0, 0xfa, 0x10, 0xba, 0x9a, 0x50, 0xbc, 0x98, 0x96, 0xf0, 0x62, 0xba, 0x33, 0x77, 0x0e, 0x32,
+	0x10, 0x2c, 0x4d, 0x28, 0x5e, 0x4f, 0x4b, 0x78, 0x3d, 0xdd, 0x59, 0x38, 0x07, 0x19, 0x96, 0x57,
-	0x2c, 0x2f, 0x25, 0x47, 0xb5, 0x3e, 0x5c, 0xfe, 0x26, 0xdf, 0x82, 0x5b, 0x17, 0x53, 0x35, 0xd3,
+	0x93, 0xab, 0x1a, 0x20, 0x2e, 0xbf, 0xc9, 0xb7, 0xe0, 0xd6, 0xd9, 0x84, 0xcd, 0x35, 0x47, 0x81,
-	0x1c, 0xf9, 0xd6, 0x32, 0xfa, 0x68, 0x73, 0x36, 0x57, 0x0b, 0x12, 0x7d, 0xf2, 0x15, 0xd8, 0xa8,
+	0xbd, 0x8c, 0x3e, 0x5a, 0x9f, 0xcf, 0xd8, 0x92, 0xc4, 0x80, 0x7c, 0x05, 0xd6, 0x1a, 0x29, 0x5b,
-	0x25, 0x6b, 0x35, 0xb1, 0xa5, 0xbe, 0x8e, 0x2a, 0x59, 0x35, 0xe5, 0xaa, 0x74, 0x6d, 0x5f, 0x95,
+	0x4f, 0xec, 0xa8, 0xdf, 0x48, 0xb5, 0xac, 0x9e, 0x72, 0x51, 0xd2, 0x76, 0x2f, 0x4a, 0x5a, 0xe7,
-	0xae, 0xf6, 0x9f, 0x0d, 0x58, 0x19, 0xb0, 0x90, 0x89, 0x97, 0x48, 0x9e, 0x39, 0x5d, 0x4e, 0x63,
+	0x2f, 0x06, 0xac, 0x0c, 0x59, 0xc4, 0xc4, 0x4b, 0xa4, 0xd0, 0x82, 0x5e, 0xa7, 0xb5, 0xb0, 0xd7,
-	0x6e, 0x97, 0x33, 0xd5, 0x46, 0x98, 0x57, 0xb7, 0x11, 0xcd, 0x0b, 0x6d, 0xc4, 0xeb, 0xd0, 0x4b,
+	0x99, 0x69, 0x26, 0xcc, 0x8b, 0x9b, 0x89, 0xf6, 0x99, 0x66, 0xe2, 0x75, 0xe8, 0x67, 0x79, 0x18,
-	0xb3, 0x20, 0xa2, 0xd9, 0xc4, 0x7d, 0xca, 0x26, 0x45, 0x02, 0x75, 0x35, 0xf6, 0x98, 0x4d, 0xb8,
+	0xd3, 0x7c, 0xea, 0x3d, 0x65, 0xd3, 0x32, 0x8d, 0x2c, 0x8d, 0x3d, 0x66, 0x53, 0xee, 0x24, 0xb0,
-	0x1d, 0xc3, 0xd6, 0x87, 0x09, 0xf5, 0xf7, 0x69, 0x48, 0x63, 0x8f, 0x69, 0x33, 0xf9, 0xf5, 0x2d,
+	0xf1, 0x61, 0x4a, 0x83, 0x5d, 0x1a, 0xd1, 0xc4, 0x67, 0xda, 0x4c, 0x7e, 0x75, 0xcb, 0xee, 0x00,
-	0xbb, 0x03, 0x50, 0x63, 0xb2, 0x81, 0x1b, 0xd6, 0x10, 0xfb, 0x6f, 0x06, 0x74, 0xe4, 0x86, 0xd8,
+	0x34, 0x98, 0x6c, 0xe1, 0x86, 0x0d, 0xc4, 0xf9, 0xbb, 0x01, 0x3d, 0xb9, 0x21, 0xb6, 0xe0, 0x57,
-	0x7c, 0x5f, 0x63, 0xfd, 0xa9, 0xae, 0xab, 0x31, 0xa7, 0xeb, 0x2a, 0xfb, 0xe7, 0x82, 0xae, 0xaa,
+	0x58, 0x7f, 0xa6, 0xf7, 0x6a, 0x2d, 0xe8, 0xbd, 0xaa, 0x2e, 0xba, 0xa4, 0xab, 0x6e, 0xab, 0x1b,
-	0xa1, 0xae, 0x35, 0xc6, 0xcd, 0xe9, 0xc6, 0xf8, 0x2e, 0x74, 0x03, 0x79, 0x20, 0x37, 0xa5, 0xe2,
+	0xed, 0x71, 0x7b, 0xb6, 0x3d, 0xbe, 0x0b, 0x56, 0x28, 0x0f, 0xe4, 0x65, 0x54, 0x9c, 0x28, 0x9e,
-	0x4c, 0xf1, 0xd4, 0x71, 0x00, 0xa1, 0x63, 0x89, 0xc8, 0xce, 0xb9, 0x50, 0xc0, 0xce, 0x79, 0x79,
+	0x7a, 0x2e, 0x20, 0x74, 0x28, 0x11, 0xd9, 0x3f, 0x97, 0x0a, 0xd8, 0x3f, 0x2f, 0x5f, 0xba, 0x7f,
-	0xe1, 0xce, 0x59, 0x2f, 0x82, 0x9d, 0xf3, 0x1f, 0x1a, 0x60, 0x69, 0x8a, 0xab, 0x67, 0xa8, 0x8f,
+	0xd6, 0x8b, 0x60, 0xff, 0xfc, 0xc7, 0x16, 0xd8, 0x9a, 0xe2, 0xfa, 0x31, 0xea, 0xa3, 0x2c, 0xc0,
-	0x52, 0x1f, 0x5f, 0xc3, 0x6e, 0x43, 0xa7, 0x8c, 0x32, 0xfd, 0x0a, 0x54, 0x01, 0x92, 0xd7, 0x43,
+	0x37, 0xb1, 0xdb, 0xd0, 0xab, 0xa2, 0x4c, 0xbf, 0x05, 0xd5, 0x80, 0xe4, 0x75, 0x9f, 0xc5, 0x69,
-	0x16, 0x25, 0xd9, 0xe4, 0x24, 0xf8, 0x94, 0x69, 0xc3, 0x6b, 0x88, 0xb4, 0xed, 0x28, 0x8f, 0x9c,
+	0x3e, 0x3d, 0x0a, 0x3f, 0x65, 0xda, 0xf0, 0x06, 0x22, 0x6d, 0x3b, 0x28, 0x62, 0x37, 0x7d, 0xc6,
-	0xe4, 0x19, 0xd7, 0x65, 0xb6, 0x18, 0x4a, 0xdb, 0x3c, 0xfc, 0xde, 0xc1, 0xea, 0x84, 0x96, 0x37,
+	0x75, 0xb1, 0x2d, 0x87, 0xd2, 0x36, 0x1f, 0x7f, 0xf5, 0x60, 0x75, 0x42, 0xcb, 0xdb, 0x2e, 0x28,
-	0x1d, 0x50, 0x90, 0xac, 0x4a, 0x64, 0x13, 0xda, 0x2c, 0xf6, 0x95, 0x74, 0x09, 0xa5, 0x2d, 0x16,
+	0x48, 0x56, 0x25, 0xb2, 0x0e, 0x5d, 0x96, 0x04, 0x4a, 0xba, 0x84, 0xd2, 0x0e, 0x4b, 0x02, 0x14,
-	0xfb, 0x28, 0x1a, 0xc2, 0xaa, 0x7e, 0x7e, 0x4a, 0x38, 0x96, 0x5c, 0x5d, 0x68, 0xed, 0x4b, 0xde,
+	0x8d, 0x60, 0x55, 0x3f, 0x42, 0xa5, 0x1c, 0x0b, 0x2f, 0x56, 0x57, 0x6b, 0xc7, 0x39, 0xe7, 0xe5,
-	0xfc, 0x0e, 0xf9, 0xf8, 0x58, 0x6b, 0x3a, 0x2b, 0xea, 0x05, 0x4a, 0x0f, 0xc9, 0x07, 0xd0, 0x93,
+	0x6f, 0x9f, 0x4f, 0x0e, 0xb5, 0xa6, 0xbb, 0xa2, 0xde, 0xa1, 0xf4, 0x90, 0x7c, 0x00, 0x7d, 0xb9,
-	0xbb, 0x94, 0x0b, 0xb5, 0x16, 0x5e, 0xa8, 0xcb, 0x62, 0xbf, 0x18, 0xd8, 0xbf, 0x34, 0xe0, 0xc6,
+	0x4b, 0xb5, 0x50, 0xe7, 0xd2, 0x0b, 0x59, 0x2c, 0x09, 0xca, 0x81, 0xf3, 0x2b, 0x03, 0xae, 0x9f,
-	0x05, 0x0a, 0xaf, 0x11, 0x47, 0x8f, 0xa1, 0x7d, 0xc2, 0xc6, 0x72, 0x89, 0xe2, 0x51, 0x6d, 0xf7,
+	0xa1, 0xf0, 0x0a, 0x71, 0xf4, 0x18, 0xba, 0x47, 0x6c, 0x22, 0x97, 0x28, 0x9f, 0xd6, 0xb6, 0xcf,
-	0xb2, 0x37, 0xda, 0x4b, 0x1c, 0xe6, 0x94, 0x0b, 0xd8, 0x3f, 0x36, 0x00, 0x30, 0xa0, 0x71, 0x78,
+	0x7b, 0xa9, 0x3d, 0xc7, 0x61, 0x6e, 0xb5, 0x80, 0xf3, 0x13, 0x03, 0x00, 0x03, 0x1a, 0x87, 0x67,
-	0x21, 0x58, 0x8c, 0xeb, 0x04, 0x8b, 0x6c, 0x39, 0xe5, 0x75, 0x9f, 0xb1, 0x90, 0x8a, 0xaa, 0x3e,
+	0x82, 0xc5, 0xb8, 0x4a, 0xb0, 0xc8, 0xfb, 0x4d, 0x5e, 0xfa, 0x39, 0x8b, 0xa8, 0xa8, 0xeb, 0x13,
-	0x71, 0xed, 0x7b, 0x12, 0xe7, 0x91, 0xa3, 0x44, 0x45, 0xd2, 0xda, 0x3f, 0x37, 0x00, 0xb0, 0xc0,
+	0xd7, 0xbe, 0x27, 0x49, 0x11, 0xbb, 0x4a, 0x54, 0x26, 0xad, 0xf3, 0x0b, 0x03, 0x00, 0x0b, 0xac,
-	0xaa, 0x63, 0xcc, 0x5e, 0xb1, 0xc6, 0xd5, 0xdf, 0x8a, 0x8d, 0xe9, 0x94, 0xd8, 0x2f, 0x52, 0x82,
+	0x3a, 0xc6, 0xfc, 0x45, 0x6b, 0x5c, 0xfc, 0x8b, 0xb1, 0x35, 0x9b, 0x12, 0xbb, 0x65, 0x4a, 0x70,
-	0x23, 0x47, 0xe6, 0x3c, 0x1b, 0x4a, 0x8e, 0x2a, 0xe3, 0x75, 0xd6, 0x28, 0x5e, 0x7e, 0x65, 0x40,
+	0xe4, 0xc8, 0x5c, 0x64, 0x43, 0xc5, 0x51, 0x6d, 0xbc, 0xce, 0x1a, 0xc5, 0xcb, 0xaf, 0x0d, 0xe8,
-	0xaf, 0x46, 0x1f, 0x9f, 0xce, 0x5e, 0x63, 0x36, 0x7b, 0xb1, 0x11, 0x94, 0x11, 0xed, 0xf2, 0x5a,
+	0x37, 0xe8, 0xe3, 0xb3, 0xd9, 0x6b, 0xcc, 0x67, 0x2f, 0xb6, 0x83, 0x32, 0xa2, 0x3d, 0xde, 0x08,
-	0x90, 0x47, 0x55, 0x90, 0x6f, 0x42, 0x1b, 0x29, 0xa9, 0x45, 0x79, 0xac, 0xa3, 0xfc, 0x1e, 0xdc,
+	0xf2, 0xb8, 0x0e, 0xf2, 0x75, 0xe8, 0x22, 0x25, 0x8d, 0x28, 0x4f, 0x74, 0x94, 0xdf, 0x83, 0xeb,
-	0xc8, 0x98, 0xc7, 0x62, 0x11, 0x4e, 0xdc, 0x28, 0xf1, 0x83, 0xd3, 0x80, 0xf9, 0x18, 0xeb, 0x6d,
+	0x39, 0xf3, 0x59, 0x22, 0xa2, 0xa9, 0x17, 0xa7, 0x41, 0x78, 0x1c, 0xb2, 0x00, 0x63, 0xbd, 0xeb,
-	0xa7, 0x5f, 0x08, 0x0e, 0x35, 0x6e, 0xff, 0xc9, 0x80, 0x55, 0xd9, 0x3b, 0x4e, 0x8e, 0x12, 0x9f,
+	0x0e, 0x4a, 0xc1, 0xbe, 0xc6, 0x9d, 0x3f, 0x1b, 0xb0, 0x2a, 0x3b, 0xc8, 0xe9, 0x41, 0x1a, 0x30,
-	0xa9, 0x93, 0xbd, 0x78, 0x04, 0xbd, 0x87, 0xb6, 0x68, 0x7a, 0x54, 0x08, 0xbd, 0xf1, 0xcf, 0x43,
+	0x75, 0xb2, 0x17, 0x8f, 0xa0, 0xf7, 0xd0, 0x16, 0x4d, 0x8f, 0x0a, 0xa1, 0x37, 0xfe, 0x79, 0x08,
-	0x88, 0x3b, 0x6d, 0xae, 0xc3, 0x46, 0x52, 0xac, 0xbe, 0xff, 0x17, 0xa1, 0xb8, 0x72, 0xac, 0xbe,
+	0x71, 0xb7, 0xcb, 0x75, 0xd8, 0x48, 0x8a, 0xd5, 0x2b, 0xc0, 0x65, 0x28, 0xae, 0x1d, 0xab, 0xaf,
-	0x3a, 0x15, 0xc5, 0x3f, 0x32, 0xa0, 0x5b, 0x4b, 0x16, 0x59, 0xf2, 0xf5, 0xfd, 0xa0, 0xae, 0x15,
+	0x4e, 0x45, 0xf1, 0x8f, 0x0c, 0xb0, 0x1a, 0xc9, 0x22, 0x4b, 0xbe, 0xbe, 0x1f, 0xd4, 0xb5, 0x62,
-	0x03, 0x8b, 0x60, 0xd7, 0xab, 0x5e, 0xf9, 0xc8, 0x06, 0x2c, 0x45, 0x7c, 0xac, 0x3d, 0xde, 0x73,
+	0x60, 0x11, 0xb4, 0xfc, 0xfa, 0xad, 0x8f, 0xac, 0xc1, 0x52, 0xcc, 0x27, 0xda, 0xe3, 0x7d, 0x57,
-	0xd4, 0x80, 0x6c, 0x41, 0x3b, 0xe2, 0x63, 0xfc, 0x4c, 0xd2, 0x95, 0xb3, 0x1c, 0x4b, 0xb7, 0x55,
+	0x0d, 0xc8, 0x06, 0x74, 0x63, 0x3e, 0xc1, 0x1f, 0x4b, 0xba, 0x72, 0x56, 0x63, 0xe9, 0xb6, 0xba,
-	0x9d, 0x8d, 0x2a, 0x20, 0x15, 0x60, 0xff, 0xc6, 0x00, 0xa2, 0x1b, 0x87, 0x97, 0x7a, 0x0a, 0xc6,
+	0xb3, 0x51, 0x05, 0xa4, 0x06, 0x9c, 0xdf, 0x1a, 0x40, 0x74, 0xe3, 0xf0, 0x52, 0x0f, 0xc2, 0x18,
-	0x80, 0xad, 0xbf, 0x54, 0x36, 0xb0, 0x0c, 0x4f, 0x61, 0x33, 0x57, 0x9e, 0x79, 0xe1, 0xca, 0xbb,
+	0xb0, 0xcd, 0xf7, 0xca, 0x16, 0x96, 0xe1, 0x19, 0x6c, 0xee, 0xca, 0x33, 0xcf, 0x5c, 0x79, 0xf7,
-	0x07, 0x37, 0x7c, 0x76, 0x4a, 0x65, 0x8f, 0x33, 0x7b, 0xe4, 0xbe, 0x16, 0x94, 0xad, 0xd8, 0x5b,
+	0xe0, 0x7a, 0xc0, 0x8e, 0xa9, 0xec, 0x71, 0xe6, 0x8f, 0x3c, 0xd0, 0x82, 0xaa, 0x15, 0x7b, 0xeb,
-	0xef, 0x42, 0xa7, 0xfc, 0x07, 0x86, 0xf4, 0xa1, 0x37, 0x8c, 0x03, 0x81, 0xdf, 0x71, 0x41, 0x3c,
+	0x5d, 0xe8, 0x55, 0xff, 0xc3, 0x90, 0x01, 0xf4, 0x47, 0x49, 0x28, 0xb0, 0x69, 0x0c, 0x93, 0xc9,
-	0xee, 0x7f, 0x8e, 0x74, 0xa1, 0xf5, 0x1d, 0x46, 0x43, 0x71, 0x36, 0xe9, 0x1b, 0xa4, 0x07, 0xed,
+	0xe0, 0x73, 0xc4, 0x82, 0xce, 0x77, 0x18, 0x8d, 0xc4, 0xc9, 0x74, 0x60, 0x90, 0x3e, 0x74, 0xdf,
-	0xf7, 0x47, 0x71, 0x92, 0x45, 0x34, 0xec, 0x37, 0xf6, 0xdf, 0xf9, 0xc1, 0xd7, 0xc6, 0x81, 0x38,
+	0x1f, 0x27, 0x69, 0x1e, 0xd3, 0x68, 0xd0, 0xda, 0x7d, 0xe7, 0x07, 0x5f, 0x9b, 0x84, 0xe2, 0xa4,
-	0xcb, 0x47, 0xd2, 0x92, 0x5d, 0x65, 0xda, 0x97, 0x83, 0x44, 0xff, 0xda, 0x2d, 0xbc, 0xb6, 0x8b,
+	0x18, 0x4b, 0x4b, 0xb6, 0x95, 0x69, 0x5f, 0x0e, 0x53, 0xfd, 0xb5, 0x5d, 0x7a, 0x6d, 0x1b, 0xad,
-	0xd6, 0x96, 0xc3, 0x74, 0x34, 0x5a, 0x46, 0xe4, 0xed, 0x7f, 0x04, 0x00, 0x00, 0xff, 0xff, 0x1b,
+	0xad, 0x86, 0xd9, 0x78, 0xbc, 0x8c, 0xc8, 0xdb, 0xff, 0x08, 0x00, 0x00, 0xff, 0xff, 0x99, 0x69,
-	0x58, 0x94, 0x0b, 0xa7, 0x1a, 0x00, 0x00,
+	0x35, 0xab, 0xad, 0x1a, 0x00, 0x00,
 }

internal/proto/plan.proto

@@ -102,6 +102,7 @@ message VectorANNS {
 message PlanNode {
   oneof node {
     VectorANNS vector_anns = 1;
+    Expr predicates = 2;
   }
-  repeated int64 output_field_ids = 2;
+  repeated int64 output_field_ids = 3;
 }

internal/proto/planpb/plan.pb.go

@@ -871,8 +871,9 @@ func (m *VectorANNS) GetPlaceholderTag() string {
 type PlanNode struct {
 	// Types that are valid to be assigned to Node:
 	//	*PlanNode_VectorAnns
+	//	*PlanNode_Predicates
 	Node                 isPlanNode_Node `protobuf_oneof:"node"`
-	OutputFieldIds       []int64         `protobuf:"varint,2,rep,packed,name=output_field_ids,json=outputFieldIds,proto3" json:"output_field_ids,omitempty"`
+	OutputFieldIds       []int64         `protobuf:"varint,3,rep,packed,name=output_field_ids,json=outputFieldIds,proto3" json:"output_field_ids,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
 	XXX_unrecognized     []byte          `json:"-"`
 	XXX_sizecache        int32           `json:"-"`
@@ -911,8 +912,14 @@ type PlanNode_VectorAnns struct {
 	VectorAnns *VectorANNS `protobuf:"bytes,1,opt,name=vector_anns,json=vectorAnns,proto3,oneof"`
 }
 
+type PlanNode_Predicates struct {
+	Predicates *Expr `protobuf:"bytes,2,opt,name=predicates,proto3,oneof"`
+}
+
 func (*PlanNode_VectorAnns) isPlanNode_Node() {}
 
+func (*PlanNode_Predicates) isPlanNode_Node() {}
+
 func (m *PlanNode) GetNode() isPlanNode_Node {
 	if m != nil {
 		return m.Node
@@ -927,6 +934,13 @@ func (m *PlanNode) GetVectorAnns() *VectorANNS {
 	return nil
 }
 
+func (m *PlanNode) GetPredicates() *Expr {
+	if x, ok := m.GetNode().(*PlanNode_Predicates); ok {
+		return x.Predicates
+	}
+	return nil
+}
+
 func (m *PlanNode) GetOutputFieldIds() []int64 {
 	if m != nil {
 		return m.OutputFieldIds
@@ -938,6 +952,7 @@ func (m *PlanNode) GetOutputFieldIds() []int64 {
 func (*PlanNode) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
 		(*PlanNode_VectorAnns)(nil),
+		(*PlanNode_Predicates)(nil),
 	}
 }
 
@@ -962,71 +977,72 @@ func init() {
 func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }
 
 var fileDescriptor_2d655ab2f7683c23 = []byte{
-	// 1055 bytes of a gzipped FileDescriptorProto
+	// 1067 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x72, 0xdb, 0x44,
-	0x14, 0xb6, 0x2c, 0xdb, 0x91, 0x8e, 0x5c, 0xdb, 0xd1, 0x0d, 0x29, 0xa1, 0x24, 0x88, 0x0e, 0x0d,
+	0x14, 0xb6, 0x2c, 0xdb, 0x91, 0x8e, 0x5c, 0xdb, 0xd5, 0x0d, 0x29, 0xa1, 0x24, 0x88, 0x0e, 0x0d,
-	0x30, 0x4d, 0x86, 0xb6, 0xa4, 0x33, 0x65, 0x60, 0xf2, 0xd3, 0x12, 0x7b, 0x28, 0x49, 0x10, 0x21,
+	0x30, 0x4d, 0x86, 0xb6, 0xa4, 0x43, 0x19, 0x98, 0xfc, 0xb4, 0xc4, 0x1e, 0x4a, 0x12, 0x44, 0xc8,
-	0x17, 0xdc, 0x68, 0xd6, 0xd2, 0xc6, 0xde, 0xe9, 0x5a, 0xab, 0xac, 0x56, 0xa6, 0xbe, 0xe1, 0x86,
+	0x05, 0x37, 0x9a, 0xb5, 0xb4, 0xb1, 0x77, 0xba, 0xd6, 0x2a, 0xab, 0x95, 0xa9, 0xaf, 0x79, 0x02,
-	0x27, 0xe0, 0x25, 0xe0, 0x1a, 0x9e, 0x83, 0x07, 0xe0, 0x9e, 0x17, 0x61, 0xf6, 0xac, 0xe2, 0x9f,
+	0x5e, 0x02, 0xae, 0xe1, 0x8e, 0x77, 0xe0, 0x01, 0xb8, 0xe7, 0x45, 0x98, 0x3d, 0xab, 0xf8, 0xa7,
-	0x8e, 0xd3, 0xa6, 0x33, 0xbd, 0x5b, 0x9d, 0x3d, 0x7f, 0xdf, 0x77, 0x7e, 0x56, 0x00, 0x19, 0x27,
+	0xe3, 0xa4, 0x61, 0xa6, 0x77, 0xab, 0xb3, 0xe7, 0xef, 0xfb, 0xce, 0xcf, 0x0a, 0x20, 0xe3, 0x24,
-	0xe9, 0x76, 0x26, 0x85, 0x12, 0xfe, 0xea, 0x88, 0xf1, 0x71, 0x91, 0x9b, 0xaf, 0x6d, 0x7d, 0xf1,
+	0xdd, 0xca, 0xa4, 0x50, 0xc2, 0xbf, 0x3d, 0x62, 0x7c, 0x5c, 0xe4, 0xe6, 0x6b, 0x4b, 0x5f, 0xbc,
-	0x7e, 0x33, 0x8f, 0x87, 0x74, 0x44, 0x8c, 0x28, 0xc8, 0xa0, 0x79, 0x44, 0x53, 0x2a, 0x59, 0x7c,
+	0xdb, 0xcc, 0xe3, 0x21, 0x1d, 0x11, 0x23, 0x0a, 0x32, 0x68, 0x1e, 0xd2, 0x94, 0x4a, 0x16, 0x9f,
-	0x4e, 0x78, 0x41, 0xfd, 0x75, 0x70, 0xfa, 0x42, 0xf0, 0x68, 0x4c, 0xf8, 0x9a, 0xb5, 0x69, 0x6d,
+	0x11, 0x5e, 0x50, 0x7f, 0x0d, 0x9c, 0xbe, 0x10, 0x3c, 0x1a, 0x13, 0xbe, 0x6a, 0x6d, 0x58, 0x9b,
-	0x39, 0xdd, 0x4a, 0xb8, 0xa2, 0x25, 0xe7, 0x84, 0xfb, 0x77, 0xc0, 0x65, 0xa9, 0xda, 0x7d, 0x84,
+	0x4e, 0xb7, 0x12, 0xae, 0x68, 0xc9, 0x19, 0xe1, 0xfe, 0x5d, 0x70, 0x59, 0xaa, 0x76, 0x1e, 0xe3,
-	0xb7, 0xd5, 0x4d, 0x6b, 0xcb, 0xee, 0x56, 0x42, 0x07, 0x45, 0xe5, 0xf5, 0x05, 0x17, 0x44, 0xe1,
+	0x6d, 0x75, 0xc3, 0xda, 0xb4, 0xbb, 0x95, 0xd0, 0x41, 0x51, 0x79, 0x7d, 0xce, 0x05, 0x51, 0x78,
-	0xb5, 0xbd, 0x69, 0x6d, 0x59, 0xfa, 0x1a, 0x45, 0xe7, 0x84, 0x1f, 0xd4, 0xc1, 0x1e, 0x13, 0x1e,
+	0x6d, 0x6f, 0x58, 0x9b, 0x96, 0xbe, 0x46, 0xd1, 0x19, 0xe1, 0xfb, 0x75, 0xb0, 0xc7, 0x84, 0x07,
-	0x50, 0x70, 0x7f, 0x28, 0xa8, 0x9c, 0xf4, 0xd2, 0x0b, 0xe1, 0xfb, 0x50, 0x53, 0x22, 0x7b, 0x81,
+	0x14, 0xdc, 0xef, 0x0b, 0x2a, 0x27, 0xbd, 0xf4, 0x5c, 0xf8, 0x3e, 0xd4, 0x94, 0xc8, 0x5e, 0x62,
-	0xa1, 0xec, 0x10, 0xcf, 0xfe, 0x06, 0x78, 0x23, 0xaa, 0x24, 0x8b, 0x23, 0x35, 0xc9, 0x28, 0x3a,
+	0x28, 0x3b, 0xc4, 0xb3, 0xbf, 0x0e, 0xde, 0x88, 0x2a, 0xc9, 0xe2, 0x48, 0x4d, 0x32, 0x8a, 0x8e,
-	0x72, 0x43, 0x30, 0xa2, 0xb3, 0x49, 0x46, 0xfd, 0x8f, 0xe1, 0x56, 0x4e, 0x89, 0x8c, 0x87, 0x51,
+	0xdc, 0x10, 0x8c, 0xe8, 0x74, 0x92, 0x51, 0xff, 0x43, 0xb8, 0x95, 0x53, 0x22, 0xe3, 0x61, 0x94,
-	0x46, 0x24, 0x19, 0xe5, 0x6b, 0x35, 0x54, 0x69, 0x1a, 0xe1, 0x29, 0xca, 0x82, 0x3f, 0x2c, 0x80,
+	0x11, 0x49, 0x46, 0xf9, 0x6a, 0x0d, 0x55, 0x9a, 0x46, 0x78, 0x82, 0xb2, 0xe0, 0x37, 0x0b, 0xe0,
-	0x43, 0xc1, 0x8b, 0x51, 0x8a, 0x81, 0x6e, 0x83, 0x73, 0xc1, 0x28, 0x4f, 0x22, 0x96, 0x94, 0xc1,
+	0x40, 0xf0, 0x62, 0x94, 0x62, 0xa0, 0x3b, 0xe0, 0x9c, 0x33, 0xca, 0x93, 0x88, 0x25, 0x65, 0xb0,
-	0x56, 0xf0, 0xbb, 0x97, 0xf8, 0x4f, 0xc0, 0x4d, 0x88, 0x22, 0x26, 0x9a, 0x46, 0xd5, 0x7a, 0x70,
+	0x15, 0xfc, 0xee, 0x25, 0xfe, 0x53, 0x70, 0x13, 0xa2, 0x88, 0x89, 0xa6, 0x51, 0xb5, 0x1e, 0xde,
-	0x67, 0x7b, 0x81, 0xb7, 0x92, 0xb1, 0xa7, 0x44, 0x11, 0x9d, 0x40, 0xe8, 0x24, 0xe5, 0xc9, 0xbf,
+	0xdd, 0x5a, 0xe0, 0xad, 0x64, 0xec, 0x19, 0x51, 0x44, 0x27, 0x10, 0x3a, 0x49, 0x79, 0xf2, 0xef,
-	0x0b, 0x2d, 0x96, 0x47, 0x99, 0x64, 0x23, 0x22, 0x27, 0xd1, 0x0b, 0x3a, 0xc1, 0x74, 0x9d, 0xb0,
+	0x41, 0x8b, 0xe5, 0x51, 0x26, 0xd9, 0x88, 0xc8, 0x49, 0xf4, 0x92, 0x4e, 0x30, 0x5d, 0x27, 0x6c,
-	0xc9, 0xf2, 0x53, 0x23, 0xfc, 0x8e, 0x4e, 0xfc, 0x75, 0x70, 0x59, 0x1e, 0x91, 0x42, 0x89, 0xde,
+	0xb2, 0xfc, 0xc4, 0x08, 0xbf, 0xa5, 0x13, 0x7f, 0x0d, 0x5c, 0x96, 0x47, 0xa4, 0x50, 0xa2, 0xf7,
-	0x53, 0x4c, 0xd6, 0x09, 0x1d, 0x96, 0xef, 0xe3, 0x77, 0xf0, 0xb7, 0x05, 0xad, 0x9f, 0x52, 0x22,
+	0x0c, 0x93, 0x75, 0x42, 0x87, 0xe5, 0x7b, 0xf8, 0x1d, 0xfc, 0x69, 0x41, 0xeb, 0xc7, 0x94, 0xc8,
-	0x27, 0x21, 0x49, 0x07, 0xf4, 0xd9, 0xcb, 0x4c, 0xfa, 0xdf, 0x80, 0x17, 0x63, 0xea, 0x11, 0x4b,
+	0x49, 0x48, 0xd2, 0x01, 0x7d, 0xfe, 0x2a, 0x93, 0xfe, 0xd7, 0xe0, 0xc5, 0x98, 0x7a, 0xc4, 0xd2,
-	0x2f, 0x04, 0xe6, 0xeb, 0xbd, 0x9a, 0x13, 0x16, 0x79, 0x06, 0x30, 0x84, 0x78, 0x06, 0xf6, 0x53,
+	0x73, 0x81, 0xf9, 0x7a, 0xaf, 0xe7, 0x84, 0x45, 0x9e, 0x01, 0x0c, 0x21, 0x9e, 0x81, 0xfd, 0x18,
-	0xa8, 0x8a, 0xac, 0x84, 0x72, 0x7b, 0x89, 0xd9, 0x49, 0x86, 0x30, 0xaa, 0x22, 0xf3, 0xbf, 0x84,
+	0xaa, 0x22, 0x2b, 0xa1, 0xdc, 0x59, 0x62, 0x76, 0x9c, 0x21, 0x8c, 0xaa, 0xc8, 0xfc, 0xcf, 0xa1,
-	0xfa, 0x58, 0x17, 0x1e, 0xf3, 0xf6, 0x1e, 0x6c, 0x2c, 0xd1, 0x9e, 0xef, 0x8f, 0xd0, 0x68, 0x07,
+	0x3e, 0xd6, 0x85, 0xc7, 0xbc, 0xbd, 0x87, 0xeb, 0x4b, 0xb4, 0xe7, 0xfb, 0x23, 0x34, 0xda, 0xc1,
-	0x7f, 0x56, 0xa1, 0x7d, 0xc0, 0xde, 0x6d, 0xd6, 0xf7, 0xa0, 0xcd, 0xc5, 0x2f, 0x54, 0x46, 0x2c,
+	0xef, 0x55, 0x68, 0xef, 0xb3, 0xb7, 0x9b, 0xf5, 0x7d, 0x68, 0x73, 0xf1, 0x33, 0x95, 0x11, 0x4b,
-	0x8d, 0x79, 0x91, 0xb3, 0xb1, 0xa9, 0x86, 0x13, 0xb6, 0x50, 0xdc, 0xbb, 0x92, 0x6a, 0xc5, 0x22,
+	0x63, 0x5e, 0xe4, 0x6c, 0x6c, 0xaa, 0xe1, 0x84, 0x2d, 0x14, 0xf7, 0x2e, 0xa5, 0x5a, 0xb1, 0xc8,
-	0xcb, 0x16, 0x14, 0x0d, 0xeb, 0x2d, 0x14, 0xcf, 0x14, 0xf7, 0xc0, 0x33, 0x1e, 0x0d, 0xc4, 0xda,
+	0xb2, 0x05, 0x45, 0xc3, 0x7a, 0x0b, 0xc5, 0x33, 0xc5, 0x5d, 0xf0, 0x8c, 0x47, 0x03, 0xb1, 0x76,
-	0xcd, 0x20, 0x02, 0xda, 0x98, 0x71, 0xd8, 0x03, 0xcf, 0x84, 0x32, 0x1e, 0xea, 0x37, 0xf4, 0x80,
+	0x33, 0x88, 0x80, 0x36, 0x66, 0x1c, 0x76, 0xc1, 0x33, 0xa1, 0x8c, 0x87, 0xfa, 0x0d, 0x3d, 0xa0,
-	0x36, 0x78, 0x0e, 0xfe, 0xb1, 0xc0, 0x3b, 0x14, 0xa3, 0x8c, 0x48, 0xc3, 0xd2, 0x11, 0x74, 0x38,
+	0x0d, 0x9e, 0x83, 0xbf, 0x2d, 0xf0, 0x0e, 0xc4, 0x28, 0x23, 0xd2, 0xb0, 0x74, 0x08, 0x1d, 0x4e,
-	0xbd, 0x50, 0xd1, 0x5b, 0x53, 0xd5, 0xd2, 0x66, 0x73, 0x1d, 0xdd, 0x83, 0x55, 0xc9, 0x06, 0xc3,
+	0xcf, 0x55, 0xf4, 0xbf, 0xa9, 0x6a, 0x69, 0xb3, 0xb9, 0x8e, 0xee, 0xc1, 0x6d, 0xc9, 0x06, 0xc3,
-	0x45, 0x4f, 0xd5, 0x9b, 0x78, 0x6a, 0xa3, 0xdd, 0xe1, 0xab, 0xfd, 0x62, 0xdf, 0xa0, 0x5f, 0x82,
+	0x45, 0x4f, 0xd5, 0x9b, 0x78, 0x6a, 0xa3, 0xdd, 0xc1, 0xeb, 0xfd, 0x62, 0xdf, 0xa0, 0x5f, 0x82,
-	0xdf, 0x2c, 0x70, 0xce, 0xa8, 0x1c, 0xbd, 0x93, 0x8a, 0x3f, 0x86, 0x06, 0xf2, 0x9a, 0xaf, 0x55,
+	0x5f, 0x2c, 0x70, 0x4e, 0xa9, 0x1c, 0xbd, 0x95, 0x8a, 0x3f, 0x81, 0x06, 0xf2, 0x9a, 0xaf, 0x56,
-	0x37, 0xed, 0x9b, 0x10, 0x5b, 0xaa, 0x07, 0xbf, 0x5b, 0xe0, 0xe2, 0xcc, 0x60, 0x1a, 0x8f, 0x30,
+	0x37, 0xec, 0x9b, 0x10, 0x5b, 0xaa, 0x07, 0xbf, 0x5a, 0xe0, 0xe2, 0xcc, 0x60, 0x1a, 0x8f, 0x31,
-	0x7d, 0x0b, 0xd3, 0xbf, 0xbb, 0xc4, 0xc5, 0x54, 0xd3, 0x9c, 0x4e, 0x32, 0xec, 0xfc, 0xfb, 0x50,
+	0x7d, 0x0b, 0xd3, 0xbf, 0xb7, 0xc4, 0xc5, 0x54, 0xd3, 0x9c, 0x8e, 0x33, 0xec, 0xfc, 0x07, 0x50,
-	0x8f, 0x87, 0x8c, 0x27, 0x25, 0x67, 0xef, 0x2d, 0x31, 0xd4, 0x36, 0xa1, 0xd1, 0x0a, 0x36, 0x60,
+	0x8f, 0x87, 0x8c, 0x27, 0x25, 0x67, 0xef, 0x2c, 0x31, 0xd4, 0x36, 0xa1, 0xd1, 0x0a, 0xd6, 0x61,
 	0xa5, 0xb4, 0xf6, 0x3d, 0x58, 0xe9, 0xa5, 0x63, 0xc2, 0x59, 0xd2, 0xa9, 0xf8, 0x2b, 0x60, 0x1f,
-	0x0b, 0xd5, 0xb1, 0x82, 0x7f, 0x2d, 0x00, 0x33, 0x12, 0x98, 0xd4, 0xee, 0x5c, 0x52, 0x9f, 0x2c,
+	0x09, 0xd5, 0xb1, 0x82, 0x7f, 0x2c, 0x00, 0x33, 0x12, 0x98, 0xd4, 0xce, 0x5c, 0x52, 0x1f, 0x2d,
-	0xf1, 0x3d, 0x53, 0x2d, 0x8f, 0x65, 0x5a, 0x9f, 0x43, 0x4d, 0x17, 0xfa, 0x4d, 0x59, 0xa1, 0x92,
+	0xf1, 0x3d, 0x53, 0x2d, 0x8f, 0x65, 0x5a, 0x9f, 0x42, 0x4d, 0x17, 0xfa, 0x4d, 0x59, 0xa1, 0x92,
-	0xc6, 0x80, 0xb5, 0x2c, 0xa7, 0xf7, 0x7a, 0x0c, 0xa8, 0x15, 0xec, 0x82, 0x73, 0x15, 0x6b, 0x11,
+	0xc6, 0x80, 0xb5, 0x2c, 0xa7, 0xf7, 0x6a, 0x0c, 0xa8, 0x15, 0xec, 0x80, 0x73, 0x19, 0x6b, 0x11,
-	0x44, 0x0b, 0xe0, 0xb9, 0x18, 0xb0, 0x98, 0xf0, 0xfd, 0x34, 0xe9, 0x58, 0xfe, 0x2d, 0x70, 0xcb,
+	0x44, 0x0b, 0xe0, 0x85, 0x18, 0xb0, 0x98, 0xf0, 0xbd, 0x34, 0xe9, 0x58, 0xfe, 0x2d, 0x70, 0xcb,
-	0xef, 0x13, 0xd9, 0xa9, 0x06, 0x7f, 0xd9, 0x50, 0x43, 0x50, 0x4f, 0xc0, 0x55, 0x54, 0x8e, 0x22,
+	0xef, 0x63, 0xd9, 0xa9, 0x06, 0x7f, 0xd8, 0x50, 0x43, 0x50, 0x4f, 0xc1, 0x55, 0x54, 0x8e, 0x22,
-	0xfa, 0x32, 0x93, 0x65, 0xb9, 0xd7, 0x97, 0xc4, 0xbc, 0x6a, 0x10, 0xbd, 0xfe, 0xd5, 0x55, 0xb3,
+	0xfa, 0x2a, 0x93, 0x65, 0xb9, 0xd7, 0x96, 0xc4, 0xbc, 0x6c, 0x10, 0xbd, 0xfe, 0xd5, 0x65, 0xb3,
-	0x7c, 0x0d, 0x50, 0xe8, 0xd8, 0xc6, 0xd8, 0xc0, 0xfb, 0xe0, 0x75, 0xd5, 0xea, 0x56, 0x42, 0xb7,
+	0x7c, 0x05, 0x50, 0xe8, 0xd8, 0xc6, 0xd8, 0xc0, 0x7b, 0xef, 0xba, 0x6a, 0x75, 0x2b, 0xa1, 0x5b,
-	0x98, 0xf2, 0xb9, 0x07, 0x5e, 0x9f, 0xcd, 0xec, 0xed, 0x6b, 0x7b, 0x6d, 0x46, 0x6c, 0xb7, 0x12,
+	0x4c, 0xf9, 0xdc, 0x05, 0xaf, 0xcf, 0x66, 0xf6, 0xf6, 0x95, 0xbd, 0x36, 0x23, 0xb6, 0x5b, 0x09,
-	0x42, 0x7f, 0x56, 0x91, 0x43, 0x68, 0xc6, 0x66, 0x10, 0x8d, 0x0b, 0xb3, 0x0e, 0x3e, 0x5c, 0xda,
+	0xa1, 0x3f, 0xab, 0xc8, 0x01, 0x34, 0x63, 0x33, 0x88, 0xc6, 0x85, 0x59, 0x07, 0xef, 0x2f, 0x6d,
-	0xae, 0xd3, 0x79, 0xed, 0x56, 0x42, 0x2f, 0x9e, 0x1b, 0xdf, 0xef, 0xa1, 0x63, 0x50, 0x48, 0xbd,
+	0xd7, 0xe9, 0xbc, 0x76, 0x2b, 0xa1, 0x17, 0xcf, 0x8d, 0xef, 0x77, 0xd0, 0x31, 0x28, 0xa4, 0xde,
-	0xf7, 0x8c, 0x23, 0xb3, 0x15, 0x3e, 0xba, 0x0e, 0xcb, 0x74, 0x43, 0x76, 0x2b, 0x61, 0xab, 0x58,
+	0x7b, 0xc6, 0x91, 0xd9, 0x0a, 0x1f, 0x5c, 0x85, 0x65, 0xba, 0x21, 0xbb, 0x95, 0xb0, 0x55, 0x2c,
-	0xdc, 0x99, 0xa7, 0xb0, 0x5a, 0xa2, 0x9a, 0xf3, 0xd7, 0x40, 0x7f, 0xc1, 0xb5, 0xd8, 0xe6, 0x1d,
+	0xee, 0xcc, 0x13, 0xb8, 0x5d, 0xa2, 0x9a, 0xf3, 0xd7, 0x40, 0x7f, 0xc1, 0x95, 0xd8, 0xe6, 0x1d,
-	0xb6, 0xfb, 0x8b, 0xa2, 0x83, 0x06, 0xd4, 0xb4, 0x93, 0xe0, 0x3f, 0x0b, 0xe0, 0x9c, 0xc6, 0x4a,
+	0xb6, 0xfb, 0x8b, 0xa2, 0xfd, 0x06, 0xd4, 0xb4, 0x93, 0xe0, 0x5f, 0x0b, 0xe0, 0x8c, 0xc6, 0x4a,
-	0xc8, 0xfd, 0xe3, 0xe3, 0x1f, 0xcb, 0x27, 0xc8, 0x28, 0x9b, 0x87, 0x5d, 0x3f, 0x41, 0xc6, 0xdf,
+	0xc8, 0xbd, 0xa3, 0xa3, 0x1f, 0xca, 0x27, 0xc8, 0x28, 0x9b, 0x87, 0x5d, 0x3f, 0x41, 0xc6, 0xdf,
-	0xc2, 0xe3, 0x58, 0x5d, 0x7c, 0x1c, 0x1f, 0x03, 0x64, 0x92, 0x26, 0x2c, 0x26, 0x8a, 0xe6, 0x6f,
+	0xc2, 0xe3, 0x58, 0x5d, 0x7c, 0x1c, 0x9f, 0x00, 0x64, 0x92, 0x26, 0x2c, 0x26, 0x8a, 0xe6, 0x6f,
-	0x6a, 0xb3, 0x39, 0x55, 0xff, 0x2b, 0x80, 0x4b, 0xfd, 0xcc, 0x9b, 0xd5, 0x50, 0xbb, 0xb6, 0xdc,
+	0x6a, 0xb3, 0x39, 0x55, 0xff, 0x4b, 0x80, 0x0b, 0xfd, 0xcc, 0x9b, 0xd5, 0x50, 0xbb, 0xb2, 0xdc,
-	0xd3, 0x7f, 0x81, 0xd0, 0xbd, 0x9c, 0xfe, 0x16, 0xdc, 0x83, 0x76, 0xc6, 0x49, 0x4c, 0x87, 0x82,
+	0xd3, 0x7f, 0x81, 0xd0, 0xbd, 0x98, 0xfe, 0x16, 0xdc, 0x87, 0x76, 0xc6, 0x49, 0x4c, 0x87, 0x82,
-	0x27, 0x54, 0x46, 0x8a, 0x0c, 0x90, 0x64, 0x37, 0x6c, 0xcd, 0x89, 0xcf, 0xc8, 0x20, 0xf8, 0x15,
+	0x27, 0x54, 0x46, 0x8a, 0x0c, 0x90, 0x64, 0x37, 0x6c, 0xcd, 0x89, 0x4f, 0xc9, 0x20, 0xf8, 0xcb,
-	0x9c, 0x53, 0x4e, 0xd2, 0x63, 0x91, 0xe0, 0xae, 0x1e, 0x23, 0xe0, 0x88, 0xa4, 0x69, 0xfe, 0x9a,
+	0x02, 0xe7, 0x84, 0x93, 0xf4, 0x48, 0x24, 0xb8, 0xac, 0xc7, 0x88, 0x38, 0x22, 0x69, 0x9a, 0x5f,
-	0x6d, 0x34, 0xa3, 0x45, 0x77, 0x88, 0xb1, 0xd9, 0x4f, 0xd3, 0xdc, 0xdf, 0x82, 0x8e, 0x28, 0x54,
+	0xb3, 0x8e, 0x66, 0xbc, 0xe8, 0x16, 0x31, 0x36, 0x7b, 0x69, 0x9a, 0xfb, 0x5f, 0x2c, 0xa0, 0xbd,
-	0x56, 0xa8, 0xe8, 0x8a, 0x0e, 0xb3, 0x99, 0xec, 0xb0, 0x65, 0xe4, 0xdf, 0x1a, 0x56, 0x72, 0xcd,
+	0x7e, 0x04, 0xb5, 0xe9, 0x1c, 0xde, 0x4d, 0xe8, 0x88, 0x42, 0x65, 0x85, 0x8a, 0x2e, 0xa9, 0xd4,
-	0x72, 0x2a, 0x12, 0xfa, 0x59, 0x0a, 0x0d, 0xb3, 0x1c, 0x17, 0xe7, 0xa9, 0x0d, 0xde, 0x91, 0xa4,
+	0x74, 0xd9, 0x9b, 0x76, 0xd8, 0x32, 0xf2, 0x6f, 0x0c, 0xa3, 0xb9, 0xae, 0x50, 0x2a, 0x12, 0xfa,
-	0x44, 0x51, 0x79, 0x36, 0x24, 0x69, 0xc7, 0xf2, 0x3b, 0xd0, 0x2c, 0x05, 0xcf, 0x2e, 0x0b, 0xc2,
+	0x49, 0x0a, 0x0d, 0xb3, 0x58, 0x17, 0x67, 0xb1, 0x0d, 0xde, 0xa1, 0xa4, 0x44, 0x51, 0x79, 0x3a,
-	0x3b, 0x55, 0xbf, 0x09, 0xce, 0x73, 0x9a, 0xe7, 0x78, 0x6f, 0xe3, 0xc0, 0xd1, 0x3c, 0x37, 0x97,
+	0x24, 0x69, 0xc7, 0xf2, 0x3b, 0xd0, 0x2c, 0x05, 0xcf, 0x2f, 0x0a, 0xc2, 0x3b, 0x55, 0xbf, 0x09,
-	0x35, 0xdf, 0x85, 0xba, 0x39, 0xd6, 0xb5, 0xde, 0xb1, 0x50, 0xe6, 0xab, 0x71, 0xf0, 0xf0, 0xe7,
+	0xce, 0x0b, 0x9a, 0xe7, 0x78, 0x6f, 0xe3, 0xb0, 0xd2, 0x3c, 0x37, 0x97, 0x35, 0xdf, 0x85, 0xba,
-	0x2f, 0x06, 0x4c, 0x0d, 0x8b, 0xfe, 0x76, 0x2c, 0x46, 0x3b, 0x06, 0xda, 0x7d, 0x26, 0xca, 0xd3,
+	0x39, 0xd6, 0xb5, 0xde, 0x91, 0x50, 0xe6, 0xab, 0xb1, 0xff, 0xe8, 0xa7, 0xcf, 0x06, 0x4c, 0x0d,
-	0x0e, 0x4b, 0x15, 0x95, 0x29, 0xe1, 0x3b, 0x88, 0x76, 0x47, 0xa3, 0xcd, 0xfa, 0xfd, 0x06, 0x7e,
+	0x8b, 0xfe, 0x56, 0x2c, 0x46, 0xdb, 0x06, 0xd4, 0x03, 0x26, 0xca, 0xd3, 0x36, 0x4b, 0x15, 0x95,
-	0x3d, 0xfc, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xda, 0x8a, 0xf0, 0x6c, 0x19, 0x0a, 0x00, 0x00,
+	0x29, 0xe1, 0xdb, 0x88, 0x73, 0x5b, 0xe3, 0xcc, 0xfa, 0xfd, 0x06, 0x7e, 0x3d, 0xfa, 0x2f, 0x00,
+	0x00, 0xff, 0xff, 0x6e, 0xb0, 0x90, 0xcb, 0x55, 0x0a, 0x00, 0x00,
 }

internal/proto/segcore.proto

@@ -4,11 +4,6 @@ package milvus.proto.segcore;
 option go_package = "github.com/milvus-io/milvus/internal/proto/segcorepb";
 import "schema.proto";
 
-message RetrieveRequest {
-  schema.IDs ids = 1;
-  repeated int64 output_fields_id = 2;
-}
-
 message RetrieveResults {
   schema.IDs ids = 1;
   repeated int64 offset = 2;

internal/proto/segcorepb/segcore.pb.go

@@ -21,53 +21,6 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
-type RetrieveRequest struct {
-	Ids                  *schemapb.IDs `protobuf:"bytes,1,opt,name=ids,proto3" json:"ids,omitempty"`
-	OutputFieldsId       []int64       `protobuf:"varint,2,rep,packed,name=output_fields_id,json=outputFieldsId,proto3" json:"output_fields_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
-
-func (m *RetrieveRequest) Reset()         { *m = RetrieveRequest{} }
-func (m *RetrieveRequest) String() string { return proto.CompactTextString(m) }
-func (*RetrieveRequest) ProtoMessage()    {}
-func (*RetrieveRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1d79fce784797357, []int{0}
-}
-
-func (m *RetrieveRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_RetrieveRequest.Unmarshal(m, b)
-}
-func (m *RetrieveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_RetrieveRequest.Marshal(b, m, deterministic)
-}
-func (m *RetrieveRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RetrieveRequest.Merge(m, src)
-}
-func (m *RetrieveRequest) XXX_Size() int {
-	return xxx_messageInfo_RetrieveRequest.Size(m)
-}
-func (m *RetrieveRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_RetrieveRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RetrieveRequest proto.InternalMessageInfo
-
-func (m *RetrieveRequest) GetIds() *schemapb.IDs {
-	if m != nil {
-		return m.Ids
-	}
-	return nil
-}
-
-func (m *RetrieveRequest) GetOutputFieldsId() []int64 {
-	if m != nil {
-		return m.OutputFieldsId
-	}
-	return nil
-}
-
 type RetrieveResults struct {
 	Ids                  *schemapb.IDs         `protobuf:"bytes,1,opt,name=ids,proto3" json:"ids,omitempty"`
 	Offset               []int64               `protobuf:"varint,2,rep,packed,name=offset,proto3" json:"offset,omitempty"`
@@ -81,7 +34,7 @@ func (m *RetrieveResults) Reset()         { *m = RetrieveResults{} }
 func (m *RetrieveResults) String() string { return proto.CompactTextString(m) }
 func (*RetrieveResults) ProtoMessage()    {}
 func (*RetrieveResults) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1d79fce784797357, []int{1}
+	return fileDescriptor_1d79fce784797357, []int{0}
 }
 
 func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
@@ -136,7 +89,7 @@ func (m *LoadFieldMeta) Reset()         { *m = LoadFieldMeta{} }
 func (m *LoadFieldMeta) String() string { return proto.CompactTextString(m) }
 func (*LoadFieldMeta) ProtoMessage()    {}
 func (*LoadFieldMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1d79fce784797357, []int{2}
+	return fileDescriptor_1d79fce784797357, []int{1}
 }
 
 func (m *LoadFieldMeta) XXX_Unmarshal(b []byte) error {
@@ -191,7 +144,7 @@ func (m *LoadSegmentMeta) Reset()         { *m = LoadSegmentMeta{} }
 func (m *LoadSegmentMeta) String() string { return proto.CompactTextString(m) }
 func (*LoadSegmentMeta) ProtoMessage()    {}
 func (*LoadSegmentMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1d79fce784797357, []int{3}
+	return fileDescriptor_1d79fce784797357, []int{2}
 }
 
 func (m *LoadSegmentMeta) XXX_Unmarshal(b []byte) error {
@@ -227,7 +180,6 @@ func (m *LoadSegmentMeta) GetTotalSize() int64 {
 }
 
 func init() {
-	proto.RegisterType((*RetrieveRequest)(nil), "milvus.proto.segcore.RetrieveRequest")
 	proto.RegisterType((*RetrieveResults)(nil), "milvus.proto.segcore.RetrieveResults")
 	proto.RegisterType((*LoadFieldMeta)(nil), "milvus.proto.segcore.LoadFieldMeta")
 	proto.RegisterType((*LoadSegmentMeta)(nil), "milvus.proto.segcore.LoadSegmentMeta")
@@ -236,28 +188,26 @@ func init() {
 func init() { proto.RegisterFile("segcore.proto", fileDescriptor_1d79fce784797357) }
 
 var fileDescriptor_1d79fce784797357 = []byte{
-	// 357 bytes of a gzipped FileDescriptorProto
+	// 326 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0x41, 0x4b, 0xeb, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4b, 0xfb, 0x40,
-	0x14, 0x85, 0x69, 0xc3, 0x2b, 0xaf, 0xb7, 0xed, 0xeb, 0x23, 0x3c, 0x1e, 0x41, 0x51, 0x4a, 0xba,
+	0x10, 0xc5, 0x69, 0xc3, 0xbf, 0xfc, 0x3b, 0x6d, 0x29, 0x04, 0x91, 0xa0, 0x28, 0xa5, 0xbd, 0x14,
-	0x09, 0x82, 0x09, 0x54, 0x11, 0x5c, 0x09, 0x5a, 0x84, 0x82, 0x6e, 0x52, 0x57, 0x6e, 0xc2, 0x34,
+	0xc1, 0x04, 0xaa, 0x08, 0x9e, 0x04, 0x2d, 0x82, 0xa0, 0x97, 0xad, 0x27, 0x2f, 0x61, 0x9a, 0x4c,
-	0xb9, 0x4d, 0x07, 0x33, 0x99, 0x98, 0xb9, 0x69, 0x4b, 0x7f, 0x88, 0xbf, 0x57, 0x32, 0x19, 0xb1,
+	0xdb, 0xc5, 0x6c, 0xb6, 0x64, 0x27, 0x6d, 0xe9, 0x07, 0xf1, 0xf3, 0xca, 0x6e, 0x22, 0x5a, 0xe8,
-	0x85, 0x6e, 0xdc, 0xcd, 0x3d, 0x73, 0xee, 0xf9, 0x4e, 0x32, 0x30, 0x50, 0x98, 0xc6, 0xb2, 0x44,
+	0x6d, 0xe7, 0xcd, 0x6f, 0xe6, 0xbd, 0x1d, 0xe8, 0x19, 0x5a, 0x26, 0xba, 0xa0, 0x70, 0x5d, 0x68,
-	0xbf, 0x28, 0x25, 0x49, 0xfb, 0x9f, 0xe0, 0xd9, 0xba, 0x52, 0xcd, 0xe4, 0x9b, 0xbb, 0x93, 0xbe,
+	0xd6, 0xfe, 0x89, 0x92, 0xd9, 0xa6, 0x34, 0x55, 0x15, 0xd6, 0xbd, 0xb3, 0xae, 0x49, 0x56, 0xa4,
-	0x8a, 0x57, 0x28, 0x58, 0xa3, 0xba, 0x29, 0x0c, 0x43, 0xa4, 0x92, 0xe3, 0x1a, 0x43, 0x7c, 0xaf,
+	0xb0, 0x52, 0x87, 0x5f, 0x0d, 0xe8, 0x0b, 0xe2, 0x42, 0xd2, 0x86, 0x04, 0x99, 0x32, 0x63, 0xe3,
-	0x50, 0x91, 0x7d, 0x01, 0x16, 0x4f, 0x94, 0xd3, 0x1a, 0xb5, 0xbc, 0xde, 0xc4, 0xf1, 0x0f, 0x43,
+	0x5f, 0x81, 0x27, 0x53, 0x13, 0x34, 0x06, 0x8d, 0x71, 0x67, 0x12, 0x84, 0x87, 0x5b, 0xaa, 0xe1,
-	0x9a, 0xdd, 0xd9, 0x54, 0x85, 0xb5, 0xc9, 0xf6, 0xe0, 0xaf, 0xac, 0xa8, 0xa8, 0x28, 0x5a, 0x72,
+	0x97, 0xa9, 0x11, 0x16, 0xf2, 0x4f, 0xa1, 0xa5, 0x17, 0x0b, 0x43, 0x1c, 0x34, 0x07, 0xde, 0xd8,
-	0xcc, 0x12, 0x15, 0xf1, 0xc4, 0x69, 0x8f, 0x2c, 0xcf, 0x0a, 0xff, 0x34, 0xfa, 0xa3, 0x96, 0x67,
+	0x13, 0x75, 0xe5, 0x3f, 0x40, 0x67, 0x21, 0x29, 0x4b, 0x4d, 0x9c, 0x22, 0x63, 0xe0, 0x0d, 0xbc,
-	0x89, 0xfb, 0xd1, 0xda, 0x27, 0xa9, 0x2a, 0x23, 0xf5, 0x23, 0xd2, 0x7f, 0xe8, 0xc8, 0xe5, 0x52,
+	0x71, 0x67, 0x72, 0x79, 0x74, 0xd7, 0xb3, 0xe5, 0xa6, 0xc8, 0x28, 0xa0, 0x1a, 0xb1, 0xef, 0xe1,
-	0x21, 0x99, 0x7c, 0x33, 0xd9, 0x77, 0xd0, 0x33, 0xe8, 0x84, 0x11, 0x73, 0xac, 0x91, 0xe5, 0xf5,
+	0x06, 0x7a, 0xaf, 0x1a, 0x53, 0xd7, 0x7c, 0x23, 0x46, 0x7f, 0x04, 0x3d, 0x25, 0xf3, 0x98, 0xa5,
-	0x26, 0xe7, 0x47, 0xb3, 0x74, 0x97, 0x29, 0x23, 0x16, 0x42, 0xb3, 0x52, 0x9f, 0xdd, 0x35, 0x0c,
+	0x22, 0xc3, 0xa8, 0xd6, 0x2e, 0x9f, 0x27, 0xba, 0x4a, 0xe6, 0xef, 0x3f, 0x9a, 0x83, 0x70, 0xf7,
-	0x9e, 0x24, 0x4b, 0xf4, 0xe5, 0x33, 0x12, 0xb3, 0xc7, 0x30, 0x10, 0x3c, 0x8f, 0x88, 0x0b, 0x54,
+	0x07, 0x6a, 0xd6, 0x10, 0xee, 0x7e, 0xa1, 0x73, 0x68, 0x17, 0x7a, 0x1b, 0x27, 0xba, 0xcc, 0x39,
-	0xc4, 0x44, 0xa1, 0xfb, 0x59, 0x61, 0x5f, 0xf0, 0xfc, 0xe5, 0x4b, 0xd3, 0x26, 0xb6, 0xdd, 0x33,
+	0xf0, 0x1c, 0xf0, 0xbf, 0xd0, 0xdb, 0x27, 0x5b, 0x0f, 0x3f, 0xa1, 0x6f, 0x7d, 0x67, 0xb4, 0x54,
-	0xb5, 0x8d, 0x89, 0x6d, 0xbf, 0x4d, 0xa7, 0xd0, 0x2d, 0xe5, 0x26, 0x8a, 0x65, 0x95, 0x93, 0x63,
+	0x94, 0xb3, 0x73, 0xbe, 0x87, 0x7f, 0x8a, 0x18, 0xed, 0x45, 0xec, 0x2f, 0x46, 0xe1, 0xb1, 0xbb,
-	0x69, 0xc3, 0xef, 0x52, 0x6e, 0x1e, 0xea, 0xd9, 0x7d, 0x83, 0x61, 0xcd, 0x9d, 0x63, 0x2a, 0x30,
+	0x86, 0x07, 0x69, 0x45, 0x35, 0xe1, 0x5f, 0x00, 0xb0, 0x66, 0xcc, 0x62, 0x23, 0xf7, 0x54, 0x87,
-	0x27, 0x4d, 0xbe, 0x85, 0x5f, 0x02, 0x89, 0xd5, 0x7f, 0xa4, 0xfe, 0x8a, 0xb1, 0x7f, 0xec, 0x01,
+	0x69, 0x3b, 0x65, 0x26, 0xf7, 0xf4, 0x78, 0xf7, 0x71, 0xbb, 0x94, 0xbc, 0x2a, 0xe7, 0x61, 0xa2,
-	0xfd, 0x83, 0xb6, 0x61, 0xb3, 0x61, 0x9f, 0x01, 0x90, 0x24, 0x96, 0x45, 0x8a, 0xef, 0xd0, 0x94,
+	0x55, 0x54, 0xad, 0xbd, 0x96, 0xba, 0x7e, 0x45, 0x32, 0x67, 0x2a, 0x72, 0xcc, 0x22, 0xe7, 0x14,
-	0xe9, 0x6a, 0x65, 0xce, 0x77, 0x78, 0x7f, 0xf3, 0x7a, 0x9d, 0x72, 0x5a, 0x55, 0x0b, 0x3f, 0x96,
+	0xd5, 0x4e, 0xeb, 0xf9, 0xbc, 0xe5, 0x84, 0x9b, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xd6,
-	0x22, 0x68, 0x62, 0x2f, 0xb9, 0x34, 0xa7, 0x80, 0xe7, 0x84, 0x65, 0xce, 0xb2, 0x40, 0x93, 0x02,
+	0xac, 0xcc, 0xf1, 0x01, 0x00, 0x00,
-	0x43, 0x2a, 0x16, 0x8b, 0x8e, 0x16, 0xae, 0x3e, 0x03, 0x00, 0x00, 0xff, 0xff, 0x12, 0x58, 0xd4,
-	0xce, 0x5a, 0x02, 0x00, 0x00,
 }

internal/proxy/impl.go

@@ -1660,13 +1660,13 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
 					MsgType:  commonpb.MsgType_Retrieve,
 					SourceID: Params.ProxyID,
 				},
-				Ids:             ids.IdArray,
 				ResultChannelID: strconv.FormatInt(Params.ProxyID, 10),
 			},
 			resultBuf: make(chan []*internalpb.RetrieveResults),
 			query:     queryRequest,
 			chMgr:     node.chMgr,
 			qc:        node.queryCoord,
+			ids:       ids.IdArray,
 		}
 
 		err := node.sched.DqQueue.Enqueue(qt)

internal/proxy/plan_parser.go

@@ -633,3 +633,22 @@ func CreateQueryPlan(schemaPb *schemapb.CollectionSchema, exprStr string, vector
 	}
 	return planNode, nil
 }
+
+func CreateExprQueryPlan(schemaPb *schemapb.CollectionSchema, exprStr string) (*planpb.PlanNode, error) {
+	schema, err := typeutil.CreateSchemaHelper(schemaPb)
+	if err != nil {
+		return nil, err
+	}
+
+	expr, err := parseQueryExpr(schema, exprStr)
+	if err != nil {
+		return nil, err
+	}
+
+	planNode := &planpb.PlanNode{
+		Node: &planpb.PlanNode_Predicates{
+			Predicates: expr,
+		},
+	}
+	return planNode, nil
+}

internal/proxy/task.go

@@ -2012,6 +2012,7 @@ type QueryTask struct {
 	query     *milvuspb.QueryRequest
 	chMgr     channelsMgr
 	qc        types.QueryCoord
+	ids       *schemapb.IDs
 }
 
 func (qt *QueryTask) TraceCtx() context.Context {
@@ -2105,6 +2106,11 @@ func parseIdsFromExpr(exprStr string, schema *typeutil.SchemaHelper) ([]int64, e
 	}
 }
 
+func IDs2Expr(fieldName string, ids []int64) string {
+	idsStr := strings.Trim(strings.Join(strings.Fields(fmt.Sprint(ids)), ", "), "[]")
+	return fieldName + " in [ " + idsStr + " ]"
+}
+
 func (qt *QueryTask) PreExecute(ctx context.Context) error {
 	qt.Base.MsgType = commonpb.MsgType_Retrieve
 	qt.Base.SourceID = Params.ProxyID
@@ -2172,31 +2178,52 @@ func (qt *QueryTask) PreExecute(ctx context.Context) error {
 	if err != nil { // err is not nil if collection not exists
 		return err
 	}
-	schemaHelper, err := typeutil.CreateSchemaHelper(schema)
+	// schemaHelper, err := typeutil.CreateSchemaHelper(schema)
-	if err != nil {
+	// if err != nil {
-		return err
+	// 	return err
-	}
+	// }
 
 	// TODO(dragondriver): necessary to check if partition was loaded into query node?
 
-	if qt.Ids == nil {
+	// if qt.Ids == nil {
-		if qt.query.Expr == "" {
+	// 	if qt.query.Expr == "" {
-			errMsg := "Query expression is empty"
+	// 		errMsg := "Query expression is empty"
-			return fmt.Errorf(errMsg)
+	// 		return fmt.Errorf(errMsg)
-		}
+	// 	}
 
-		ids, err := parseIdsFromExpr(qt.query.Expr, schemaHelper)
+	// 	ids, err := parseIdsFromExpr(qt.query.Expr, schemaHelper)
-		if err != nil {
+	// 	if err != nil {
-			return err
+	// 		return err
-		}
+	// 	}
-		qt.Base.MsgType = commonpb.MsgType_Retrieve
+	// 	qt.Base.MsgType = commonpb.MsgType_Retrieve
-		qt.Ids = &schemapb.IDs{
+	// 	qt.Ids = &schemapb.IDs{
-			IdField: &schemapb.IDs_IntId{
+	// 		IdField: &schemapb.IDs_IntId{
-				IntId: &schemapb.LongArray{
+	// 			IntId: &schemapb.LongArray{
-					Data: ids,
+	// 				Data: ids,
-				},
+	// 			},
-			},
+	// 		},
+	// 	}
+	// }
+
+	if qt.ids != nil {
+		pkField := ""
+		for _, field := range schema.Fields {
+			if field.IsPrimaryKey {
+				pkField = field.Name
+			}
 		}
+		qt.query.Expr = IDs2Expr(pkField, qt.ids.GetIntId().Data)
+	}
+
+	if qt.query.Expr == "" {
+		errMsg := "Query expression is empty"
+		return fmt.Errorf(errMsg)
+	}
+
+	plan, err := CreateExprQueryPlan(schema, qt.query.Expr)
+	if err != nil {
+		//return errors.New("invalid expression: " + st.query.Dsl)
+		return err
 	}
 	qt.query.OutputFields, err = translateOutputFields(qt.query.OutputFields, schema, true)
 	if err != nil {
@@ -2220,9 +2247,11 @@ func (qt *QueryTask) PreExecute(ctx context.Context) error {
 					}
 					findField = true
 					qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
+					plan.OutputFieldIds = append(plan.OutputFieldIds, field.FieldID)
 				} else {
 					if field.IsPrimaryKey && !addPrimaryKey {
 						qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
+						plan.OutputFieldIds = append(plan.OutputFieldIds, field.FieldID)
 						addPrimaryKey = true
 					}
 				}
@@ -2235,6 +2264,11 @@ func (qt *QueryTask) PreExecute(ctx context.Context) error {
 	}
 	log.Debug("translate output fields to field ids", zap.Any("OutputFieldsID", qt.OutputFieldsId))
 
+	qt.RetrieveRequest.SerializedExprPlan, err = proto.Marshal(plan)
+	if err != nil {
+		return err
+	}
+
 	travelTimestamp := qt.query.TravelTimestamp
 	if travelTimestamp == 0 {
 		travelTimestamp = qt.BeginTs()

internal/querynode/plan.go

@@ -23,8 +23,6 @@ import "C"
 import (
 	"errors"
 	"unsafe"
-
-	"github.com/milvus-io/milvus/internal/proto/segcorepb"
 )
 
 type SearchPlan struct {
@@ -110,19 +108,36 @@ type RetrievePlan struct {
 	Timestamp     uint64
 }
 
-func createRetrievePlan(col *Collection, msg *segcorepb.RetrieveRequest, timestamp uint64) (*RetrievePlan, error) {
+// func createRetrievePlan(col *Collection, msg *segcorepb.RetrieveRequest, timestamp uint64) (*RetrievePlan, error) {
-	protoCGo, err := MarshalForCGo(msg)
+// 	protoCGo, err := MarshalForCGo(msg)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	plan := new(RetrievePlan)
+// 	plan.Timestamp = timestamp
+// 	status := C.CreateRetrievePlan(col.collectionPtr, protoCGo.CProto, &plan.cRetrievePlan)
+// 	err2 := HandleCStatus(&status, "create retrieve plan failed")
+// 	if err2 != nil {
+// 		return nil, err2
+// 	}
+// 	return plan, nil
+// }
+
+func createRetrievePlanByExpr(col *Collection, expr []byte, timestamp uint64) (*RetrievePlan, error) {
+	var cPlan C.CRetrievePlan
+	status := C.CreateRetrievePlanByExpr(col.collectionPtr, (*C.char)(unsafe.Pointer(&expr[0])),
+		(C.int64_t)(len(expr)), &cPlan)
+
+	err := HandleCStatus(&status, "Create retrieve plan by expr failed")
 	if err != nil {
 		return nil, err
 	}
-	plan := new(RetrievePlan)
+
-	plan.Timestamp = timestamp
+	var newPlan = &RetrievePlan{
-	status := C.CreateRetrievePlan(col.collectionPtr, protoCGo.CProto, &plan.cRetrievePlan)
+		cRetrievePlan: cPlan,
-	err2 := HandleCStatus(&status, "create retrieve plan failed")
+		Timestamp:     timestamp,
-	if err2 != nil {
-		return nil, err2
 	}
-	return plan, nil
+	return newPlan, nil
 }
 
 func (plan *RetrievePlan) delete() {

internal/querynode/query_collection.go

@@ -1045,12 +1045,8 @@ func (q *queryCollection) retrieve(msg queryMsg) error {
 		return err
 	}
 
-	req := &segcorepb.RetrieveRequest{
+	expr := retrieveMsg.SerializedExprPlan
-		Ids:            retrieveMsg.Ids,
+	plan, err := createRetrievePlanByExpr(collection, expr, timestamp)
-		OutputFieldsId: retrieveMsg.OutputFieldsId,
-	}
-
-	plan, err := createRetrievePlan(collection, req, timestamp)
 	if err != nil {
 		return err
 	}

internal/querynode/query_node_test.go

@@ -120,6 +120,25 @@ func genTestCollectionMeta(collectionID UniqueID, isBinary bool) *etcdpb.Collect
 	return &collectionMeta
 }
 
+func genTestCollectionMetaWithPK(collectionID UniqueID, isBinary bool) *etcdpb.CollectionInfo {
+	schema := genTestCollectionSchema(collectionID, isBinary, 16)
+	schema.Fields = append(schema.Fields, &schemapb.FieldSchema{
+		FieldID:      UniqueID(0),
+		Name:         "id",
+		IsPrimaryKey: true,
+		DataType:     schemapb.DataType_Int64,
+	})
+
+	collectionMeta := etcdpb.CollectionInfo{
+		ID:           collectionID,
+		Schema:       schema,
+		CreateTime:   Timestamp(0),
+		PartitionIDs: []UniqueID{defaultPartitionID},
+	}
+
+	return &collectionMeta
+}
+
 func initTestMeta(t *testing.T, node *QueryNode, collectionID UniqueID, segmentID UniqueID, optional ...bool) {
 	isBinary := false
 	if len(optional) > 0 {

internal/querynode/segment.go

@@ -312,7 +312,7 @@ func (s *Segment) getEntityByIds(plan *RetrievePlan) (*segcorepb.RetrieveResults
 	if s.segmentPtr == nil {
 		return nil, errors.New("null seg core pointer")
 	}
-	resProto := C.GetEntityByIds(s.segmentPtr, plan.cRetrievePlan, C.uint64_t(plan.Timestamp))
+	resProto := C.Retrieve(s.segmentPtr, plan.cRetrievePlan, C.uint64_t(plan.Timestamp))
 	result := new(segcorepb.RetrieveResults)
 	err := HandleCProtoResult(&resProto, result)
 	if err != nil {

internal/querynode/segment_test.go

@@ -23,8 +23,8 @@ import (
 
 	"github.com/milvus-io/milvus/internal/proto/commonpb"
 	"github.com/milvus-io/milvus/internal/proto/milvuspb"
+	"github.com/milvus-io/milvus/internal/proto/planpb"
 	"github.com/milvus-io/milvus/internal/proto/schemapb"
-	"github.com/milvus-io/milvus/internal/proto/segcorepb"
 )
 
 //-------------------------------------------------------------------------------------- constructor and destructor
@@ -133,7 +133,7 @@ func TestSegment_retrieve(t *testing.T) {
 			rawData = append(rawData, buf...)
 		}
 		bs := make([]byte, 4)
-		binary.LittleEndian.PutUint32(bs, 1)
+		binary.LittleEndian.PutUint32(bs, uint32(i+1))
 		rawData = append(rawData, bs...)
 		blob := &commonpb.Blob{
 			Value: rawData,
@@ -146,24 +146,58 @@ func TestSegment_retrieve(t *testing.T) {
 	err = segment.segmentInsert(offset, &ids, &timestamps, &records)
 	assert.NoError(t, err)
 
-	reqIds := &segcorepb.RetrieveRequest{
+	planNode := &planpb.PlanNode{
-		Ids: &schemapb.IDs{
+		Node: &planpb.PlanNode_Predicates{
-			IdField: &schemapb.IDs_IntId{
+			Predicates: &planpb.Expr{
-				IntId: &schemapb.LongArray{
+				Expr: &planpb.Expr_TermExpr{
-					Data: []int64{2, 3, 1},
+					TermExpr: &planpb.TermExpr{
+						ColumnInfo: &planpb.ColumnInfo{
+							FieldId:  101,
+							DataType: schemapb.DataType_Int32,
+						},
+						Values: []*planpb.GenericValue{
+							{
+								Val: &planpb.GenericValue_Int64Val{
+									Int64Val: 1,
+								},
+							},
+							{
+								Val: &planpb.GenericValue_Int64Val{
+									Int64Val: 2,
+								},
+							},
+							{
+								Val: &planpb.GenericValue_Int64Val{
+									Int64Val: 3,
+								},
+							},
+						},
+					},
 				},
 			},
 		},
-		OutputFieldsId: []int64{100},
+		OutputFieldIds: []int64{101},
 	}
-	plan, err := createRetrievePlan(collection, reqIds, 100)
+	// reqIds := &segcorepb.RetrieveRequest{
+	// 	Ids: &schemapb.IDs{
+	// 		IdField: &schemapb.IDs_IntId{
+	// 			IntId: &schemapb.LongArray{
+	// 				Data: []int64{2, 3, 1},
+	// 			},
+	// 		},
+	// 	},
+	// 	OutputFieldsId: []int64{100},
+	// }
+	planExpr, err := proto.Marshal(planNode)
+	assert.NoError(t, err)
+	plan, err := createRetrievePlanByExpr(collection, planExpr, 100)
 	defer plan.delete()
 	assert.NoError(t, err)
 
 	res, err := segment.getEntityByIds(plan)
 	assert.NoError(t, err)
 
-	assert.Equal(t, res.Ids.GetIntId().Data, []int64{2, 3, 1})
+	assert.Equal(t, res.GetFieldsData()[0].GetScalars().Data.(*schemapb.ScalarField_IntData).IntData.Data, []int32{1, 2, 3})
 }
 
 func TestSegment_getDeletedCount(t *testing.T) {

tests/python_client/testcases/entity/test_query.py

@@ -273,8 +273,9 @@ class TestQueryBase:
         with pytest.raises(Exception):
             connect.query(collection, term_expr)
 
+    # TODO(yukun): "not in" is supported now
     @pytest.mark.parametrize("expr", [f'{default_int_field_name} inn [1, 2]',
-                                      f'{default_int_field_name} not in [1, 2]',
+                                    #   f'{default_int_field_name} not in [1, 2]',
                                       f'{default_int_field_name} in not [1, 2]'])
     @pytest.mark.tags(CaseLabel.L0)
     def test_query_expr_wrong_term_keyword(self, connect, collection, expr):
@@ -368,7 +369,8 @@ class TestQueryBase:
                 assert res[index][default_float_field_name] == entities[1]["values"][index]
                 ut.assert_equal_vector(res[index][ut.default_float_vec_field_name], entities[2]["values"][index])
 
-    @pytest.mark.tags(CaseLabel.L0)
+    # @pytest.mark.tags(CaseLabel.L0)
+    @pytest.mark.xfail(reason="Need to discuss")
     def test_query_expr_repeated_term_array(self, connect, collection):
         """
         target: test query with repeated term array on primary field with unique value

tests/python_client/testcases/test_query_20.py

@@ -202,9 +202,10 @@ class TestQueryBase(TestcaseBase):
         error_1 = {ct.err_code: 1, ct.err_msg: f'unexpected token Identifier("inn")'}
         collection_w.query(expr_1, check_task=CheckTasks.err_res, check_items=error_1)
 
-        expr_2 = f'{ct.default_int64_field_name} not in [1, 2]'
+        # TODO(yukun): "not in" is supported now
-        error_2 = {ct.err_code: 1, ct.err_msg: 'not top level term'}
+        # expr_2 = f'{ct.default_int64_field_name} not in [1, 2]'
-        collection_w.query(expr_2, check_task=CheckTasks.err_res, check_items=error_2)
+        # error_2 = {ct.err_code: 1, ct.err_msg: 'not top level term'}
+        # collection_w.query(expr_2, check_task=CheckTasks.err_res, check_items=error_2)
 
         expr_3 = f'{ct.default_int64_field_name} in not [1, 2]'
         error_3 = {ct.err_code: 1, ct.err_msg: 'right operand of the InExpr must be array'}