Add Retrieve method grpc definition (#5294)

See also: #5253 

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

internal/core/src/pb/milvus.pb.h

@@ -50,7 +50,7 @@ struct TableStruct_milvus_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[51]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[53]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -186,6 +186,12 @@ extern ReleaseCollectionRequestDefaultTypeInternal _ReleaseCollectionRequest_def
 class ReleasePartitionsRequest;
 class ReleasePartitionsRequestDefaultTypeInternal;
 extern ReleasePartitionsRequestDefaultTypeInternal _ReleasePartitionsRequest_default_instance_;
+class RetrieveRequest;
+class RetrieveRequestDefaultTypeInternal;
+extern RetrieveRequestDefaultTypeInternal _RetrieveRequest_default_instance_;
+class RetrieveResults;
+class RetrieveResultsDefaultTypeInternal;
+extern RetrieveResultsDefaultTypeInternal _RetrieveResults_default_instance_;
 class SearchRequest;
 class SearchRequestDefaultTypeInternal;
 extern SearchRequestDefaultTypeInternal _SearchRequest_default_instance_;
@@ -259,6 +265,8 @@ template<> ::milvus::proto::milvus::RegisterLinkRequest* Arena::CreateMaybeMessa
 template<> ::milvus::proto::milvus::RegisterLinkResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::RegisterLinkResponse>(Arena*);
 template<> ::milvus::proto::milvus::ReleaseCollectionRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ReleaseCollectionRequest>(Arena*);
 template<> ::milvus::proto::milvus::ReleasePartitionsRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ReleasePartitionsRequest>(Arena*);
+template<> ::milvus::proto::milvus::RetrieveRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::RetrieveRequest>(Arena*);
+template<> ::milvus::proto::milvus::RetrieveResults* Arena::CreateMaybeMessage<::milvus::proto::milvus::RetrieveResults>(Arena*);
 template<> ::milvus::proto::milvus::SearchRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::SearchRequest>(Arena*);
 template<> ::milvus::proto::milvus::SearchResults* Arena::CreateMaybeMessage<::milvus::proto::milvus::SearchResults>(Arena*);
 template<> ::milvus::proto::milvus::ShowCollectionsRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ShowCollectionsRequest>(Arena*);
@@ -6932,6 +6940,371 @@ class SearchRequest :
 };
 // -------------------------------------------------------------------
 
+class RetrieveRequest :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.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 =
+    40;
+
+  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.milvus.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_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPartitionNamesFieldNumber = 4,
+    kOutputFieldsFieldNumber = 6,
+    kDbNameFieldNumber = 2,
+    kCollectionNameFieldNumber = 3,
+    kBaseFieldNumber = 1,
+    kIdsFieldNumber = 5,
+  };
+  // repeated string partition_names = 4;
+  int partition_names_size() const;
+  void clear_partition_names();
+  const std::string& partition_names(int index) const;
+  std::string* mutable_partition_names(int index);
+  void set_partition_names(int index, const std::string& value);
+  void set_partition_names(int index, std::string&& value);
+  void set_partition_names(int index, const char* value);
+  void set_partition_names(int index, const char* value, size_t size);
+  std::string* add_partition_names();
+  void add_partition_names(const std::string& value);
+  void add_partition_names(std::string&& value);
+  void add_partition_names(const char* value);
+  void add_partition_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_names();
+
+  // repeated string output_fields = 6;
+  int output_fields_size() const;
+  void clear_output_fields();
+  const std::string& output_fields(int index) const;
+  std::string* mutable_output_fields(int index);
+  void set_output_fields(int index, const std::string& value);
+  void set_output_fields(int index, std::string&& value);
+  void set_output_fields(int index, const char* value);
+  void set_output_fields(int index, const char* value, size_t size);
+  std::string* add_output_fields();
+  void add_output_fields(const std::string& value);
+  void add_output_fields(std::string&& value);
+  void add_output_fields(const char* value);
+  void add_output_fields(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output_fields() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output_fields();
+
+  // string db_name = 2;
+  void clear_db_name();
+  const std::string& db_name() const;
+  void set_db_name(const std::string& value);
+  void set_db_name(std::string&& value);
+  void set_db_name(const char* value);
+  void set_db_name(const char* value, size_t size);
+  std::string* mutable_db_name();
+  std::string* release_db_name();
+  void set_allocated_db_name(std::string* db_name);
+
+  // string collection_name = 3;
+  void clear_collection_name();
+  const std::string& collection_name() const;
+  void set_collection_name(const std::string& value);
+  void set_collection_name(std::string&& value);
+  void set_collection_name(const char* value);
+  void set_collection_name(const char* value, size_t size);
+  std::string* mutable_collection_name();
+  std::string* release_collection_name();
+  void set_allocated_collection_name(std::string* collection_name);
+
+  // .milvus.proto.common.MsgBase base = 1;
+  bool has_base() const;
+  void clear_base();
+  const ::milvus::proto::common::MsgBase& base() const;
+  ::milvus::proto::common::MsgBase* release_base();
+  ::milvus::proto::common::MsgBase* mutable_base();
+  void set_allocated_base(::milvus::proto::common::MsgBase* base);
+
+  // .milvus.proto.schema.IDs ids = 5;
+  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.milvus.RetrieveRequest)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_names_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_fields_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
+  ::milvus::proto::common::MsgBase* base_;
+  ::milvus::proto::schema::IDs* ids_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RetrieveResults :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.RetrieveResults) */ {
+ public:
+  RetrieveResults();
+  virtual ~RetrieveResults();
+
+  RetrieveResults(const RetrieveResults& from);
+  RetrieveResults(RetrieveResults&& from) noexcept
+    : RetrieveResults() {
+    *this = ::std::move(from);
+  }
+
+  inline RetrieveResults& operator=(const RetrieveResults& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RetrieveResults& operator=(RetrieveResults&& 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 RetrieveResults& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RetrieveResults* internal_default_instance() {
+    return reinterpret_cast<const RetrieveResults*>(
+               &_RetrieveResults_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    41;
+
+  friend void swap(RetrieveResults& a, RetrieveResults& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RetrieveResults* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RetrieveResults* New() const final {
+    return CreateMaybeMessage<RetrieveResults>(nullptr);
+  }
+
+  RetrieveResults* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RetrieveResults>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const RetrieveResults& from);
+  void MergeFrom(const RetrieveResults& 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(RetrieveResults* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.proto.milvus.RetrieveResults";
+  }
+  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_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldsDataFieldNumber = 3,
+    kStatusFieldNumber = 1,
+    kIdsFieldNumber = 2,
+  };
+  // repeated .milvus.proto.schema.FieldData fields_data = 3;
+  int fields_data_size() const;
+  void clear_fields_data();
+  ::milvus::proto::schema::FieldData* mutable_fields_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >*
+      mutable_fields_data();
+  const ::milvus::proto::schema::FieldData& fields_data(int index) const;
+  ::milvus::proto::schema::FieldData* add_fields_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >&
+      fields_data() const;
+
+  // .milvus.proto.common.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::proto::common::Status& status() const;
+  ::milvus::proto::common::Status* release_status();
+  ::milvus::proto::common::Status* mutable_status();
+  void set_allocated_status(::milvus::proto::common::Status* status);
+
+  // .milvus.proto.schema.IDs ids = 2;
+  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.milvus.RetrieveResults)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData > fields_data_;
+  ::milvus::proto::common::Status* status_;
+  ::milvus::proto::schema::IDs* ids_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
 class Hits :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.Hits) */ {
  public:
@@ -6974,7 +7347,7 @@ class Hits :
                &_Hits_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    40;
+    42;
 
   friend void swap(Hits& a, Hits& b) {
     a.Swap(&b);
@@ -7145,7 +7518,7 @@ class SearchResults :
                &_SearchResults_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    41;
+    43;
 
   friend void swap(SearchResults& a, SearchResults& b) {
     a.Swap(&b);
@@ -7298,7 +7671,7 @@ class FlushRequest :
                &_FlushRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    42;
+    44;
 
   friend void swap(FlushRequest& a, FlushRequest& b) {
     a.Swap(&b);
@@ -7464,7 +7837,7 @@ class PersistentSegmentInfo :
                &_PersistentSegmentInfo_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    43;
+    45;
 
   friend void swap(PersistentSegmentInfo& a, PersistentSegmentInfo& b) {
     a.Swap(&b);
@@ -7651,7 +8024,7 @@ class GetPersistentSegmentInfoRequest :
                &_GetPersistentSegmentInfoRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    44;
+    46;
 
   friend void swap(GetPersistentSegmentInfoRequest& a, GetPersistentSegmentInfoRequest& b) {
     a.Swap(&b);
@@ -7811,7 +8184,7 @@ class GetPersistentSegmentInfoResponse :
                &_GetPersistentSegmentInfoResponse_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    45;
+    47;
 
   friend void swap(GetPersistentSegmentInfoResponse& a, GetPersistentSegmentInfoResponse& b) {
     a.Swap(&b);
@@ -7958,7 +8331,7 @@ class QuerySegmentInfo :
                &_QuerySegmentInfo_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    46;
+    48;
 
   friend void swap(QuerySegmentInfo& a, QuerySegmentInfo& b) {
     a.Swap(&b);
@@ -8137,7 +8510,7 @@ class GetQuerySegmentInfoRequest :
                &_GetQuerySegmentInfoRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    47;
+    49;
 
   friend void swap(GetQuerySegmentInfoRequest& a, GetQuerySegmentInfoRequest& b) {
     a.Swap(&b);
@@ -8297,7 +8670,7 @@ class GetQuerySegmentInfoResponse :
                &_GetQuerySegmentInfoResponse_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    48;
+    50;
 
   friend void swap(GetQuerySegmentInfoResponse& a, GetQuerySegmentInfoResponse& b) {
     a.Swap(&b);
@@ -8444,7 +8817,7 @@ class RegisterLinkRequest :
                &_RegisterLinkRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    49;
+    51;
 
   friend void swap(RegisterLinkRequest& a, RegisterLinkRequest& b) {
     a.Swap(&b);
@@ -8566,7 +8939,7 @@ class RegisterLinkResponse :
                &_RegisterLinkResponse_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    50;
+    52;
 
   friend void swap(RegisterLinkResponse& a, RegisterLinkResponse& b) {
     a.Swap(&b);
@@ -14963,6 +15336,453 @@ SearchRequest::search_params() const {
 
 // -------------------------------------------------------------------
 
+// RetrieveRequest
+
+// .milvus.proto.common.MsgBase base = 1;
+inline bool RetrieveRequest::has_base() const {
+  return this != internal_default_instance() && base_ != nullptr;
+}
+inline const ::milvus::proto::common::MsgBase& RetrieveRequest::base() const {
+  const ::milvus::proto::common::MsgBase* p = base_;
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveRequest.base)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
+      &::milvus::proto::common::_MsgBase_default_instance_);
+}
+inline ::milvus::proto::common::MsgBase* RetrieveRequest::release_base() {
+  // @@protoc_insertion_point(field_release:milvus.proto.milvus.RetrieveRequest.base)
+  
+  ::milvus::proto::common::MsgBase* temp = base_;
+  base_ = nullptr;
+  return temp;
+}
+inline ::milvus::proto::common::MsgBase* RetrieveRequest::mutable_base() {
+  
+  if (base_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
+    base_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveRequest.base)
+  return base_;
+}
+inline void RetrieveRequest::set_allocated_base(::milvus::proto::common::MsgBase* base) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_);
+  }
+  if (base) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, base, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  base_ = base;
+  // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.RetrieveRequest.base)
+}
+
+// string db_name = 2;
+inline void RetrieveRequest::clear_db_name() {
+  db_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& RetrieveRequest::db_name() const {
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveRequest.db_name)
+  return db_name_.GetNoArena();
+}
+inline void RetrieveRequest::set_db_name(const std::string& value) {
+  
+  db_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.RetrieveRequest.db_name)
+}
+inline void RetrieveRequest::set_db_name(std::string&& value) {
+  
+  db_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.RetrieveRequest.db_name)
+}
+inline void RetrieveRequest::set_db_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  db_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.RetrieveRequest.db_name)
+}
+inline void RetrieveRequest::set_db_name(const char* value, size_t size) {
+  
+  db_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.RetrieveRequest.db_name)
+}
+inline std::string* RetrieveRequest::mutable_db_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveRequest.db_name)
+  return db_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* RetrieveRequest::release_db_name() {
+  // @@protoc_insertion_point(field_release:milvus.proto.milvus.RetrieveRequest.db_name)
+  
+  return db_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void RetrieveRequest::set_allocated_db_name(std::string* db_name) {
+  if (db_name != nullptr) {
+    
+  } else {
+    
+  }
+  db_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), db_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.RetrieveRequest.db_name)
+}
+
+// string collection_name = 3;
+inline void RetrieveRequest::clear_collection_name() {
+  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& RetrieveRequest::collection_name() const {
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveRequest.collection_name)
+  return collection_name_.GetNoArena();
+}
+inline void RetrieveRequest::set_collection_name(const std::string& value) {
+  
+  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.RetrieveRequest.collection_name)
+}
+inline void RetrieveRequest::set_collection_name(std::string&& value) {
+  
+  collection_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.RetrieveRequest.collection_name)
+}
+inline void RetrieveRequest::set_collection_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.RetrieveRequest.collection_name)
+}
+inline void RetrieveRequest::set_collection_name(const char* value, size_t size) {
+  
+  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.RetrieveRequest.collection_name)
+}
+inline std::string* RetrieveRequest::mutable_collection_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveRequest.collection_name)
+  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* RetrieveRequest::release_collection_name() {
+  // @@protoc_insertion_point(field_release:milvus.proto.milvus.RetrieveRequest.collection_name)
+  
+  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void RetrieveRequest::set_allocated_collection_name(std::string* collection_name) {
+  if (collection_name != nullptr) {
+    
+  } else {
+    
+  }
+  collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.RetrieveRequest.collection_name)
+}
+
+// repeated string partition_names = 4;
+inline int RetrieveRequest::partition_names_size() const {
+  return partition_names_.size();
+}
+inline void RetrieveRequest::clear_partition_names() {
+  partition_names_.Clear();
+}
+inline const std::string& RetrieveRequest::partition_names(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveRequest.partition_names)
+  return partition_names_.Get(index);
+}
+inline std::string* RetrieveRequest::mutable_partition_names(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveRequest.partition_names)
+  return partition_names_.Mutable(index);
+}
+inline void RetrieveRequest::set_partition_names(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.RetrieveRequest.partition_names)
+  partition_names_.Mutable(index)->assign(value);
+}
+inline void RetrieveRequest::set_partition_names(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.RetrieveRequest.partition_names)
+  partition_names_.Mutable(index)->assign(std::move(value));
+}
+inline void RetrieveRequest::set_partition_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  partition_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.RetrieveRequest.partition_names)
+}
+inline void RetrieveRequest::set_partition_names(int index, const char* value, size_t size) {
+  partition_names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.RetrieveRequest.partition_names)
+}
+inline std::string* RetrieveRequest::add_partition_names() {
+  // @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.RetrieveRequest.partition_names)
+  return partition_names_.Add();
+}
+inline void RetrieveRequest::add_partition_names(const std::string& value) {
+  partition_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.RetrieveRequest.partition_names)
+}
+inline void RetrieveRequest::add_partition_names(std::string&& value) {
+  partition_names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.RetrieveRequest.partition_names)
+}
+inline void RetrieveRequest::add_partition_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  partition_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:milvus.proto.milvus.RetrieveRequest.partition_names)
+}
+inline void RetrieveRequest::add_partition_names(const char* value, size_t size) {
+  partition_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:milvus.proto.milvus.RetrieveRequest.partition_names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+RetrieveRequest::partition_names() const {
+  // @@protoc_insertion_point(field_list:milvus.proto.milvus.RetrieveRequest.partition_names)
+  return partition_names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+RetrieveRequest::mutable_partition_names() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.RetrieveRequest.partition_names)
+  return &partition_names_;
+}
+
+// .milvus.proto.schema.IDs ids = 5;
+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.milvus.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.milvus.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.milvus.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.milvus.RetrieveRequest.ids)
+}
+
+// repeated string output_fields = 6;
+inline int RetrieveRequest::output_fields_size() const {
+  return output_fields_.size();
+}
+inline void RetrieveRequest::clear_output_fields() {
+  output_fields_.Clear();
+}
+inline const std::string& RetrieveRequest::output_fields(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveRequest.output_fields)
+  return output_fields_.Get(index);
+}
+inline std::string* RetrieveRequest::mutable_output_fields(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveRequest.output_fields)
+  return output_fields_.Mutable(index);
+}
+inline void RetrieveRequest::set_output_fields(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.RetrieveRequest.output_fields)
+  output_fields_.Mutable(index)->assign(value);
+}
+inline void RetrieveRequest::set_output_fields(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.RetrieveRequest.output_fields)
+  output_fields_.Mutable(index)->assign(std::move(value));
+}
+inline void RetrieveRequest::set_output_fields(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  output_fields_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.RetrieveRequest.output_fields)
+}
+inline void RetrieveRequest::set_output_fields(int index, const char* value, size_t size) {
+  output_fields_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.RetrieveRequest.output_fields)
+}
+inline std::string* RetrieveRequest::add_output_fields() {
+  // @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.RetrieveRequest.output_fields)
+  return output_fields_.Add();
+}
+inline void RetrieveRequest::add_output_fields(const std::string& value) {
+  output_fields_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.RetrieveRequest.output_fields)
+}
+inline void RetrieveRequest::add_output_fields(std::string&& value) {
+  output_fields_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.RetrieveRequest.output_fields)
+}
+inline void RetrieveRequest::add_output_fields(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  output_fields_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:milvus.proto.milvus.RetrieveRequest.output_fields)
+}
+inline void RetrieveRequest::add_output_fields(const char* value, size_t size) {
+  output_fields_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:milvus.proto.milvus.RetrieveRequest.output_fields)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+RetrieveRequest::output_fields() const {
+  // @@protoc_insertion_point(field_list:milvus.proto.milvus.RetrieveRequest.output_fields)
+  return output_fields_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+RetrieveRequest::mutable_output_fields() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.RetrieveRequest.output_fields)
+  return &output_fields_;
+}
+
+// -------------------------------------------------------------------
+
+// RetrieveResults
+
+// .milvus.proto.common.Status status = 1;
+inline bool RetrieveResults::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::proto::common::Status& RetrieveResults::status() const {
+  const ::milvus::proto::common::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveResults.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
+      &::milvus::proto::common::_Status_default_instance_);
+}
+inline ::milvus::proto::common::Status* RetrieveResults::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.proto.milvus.RetrieveResults.status)
+  
+  ::milvus::proto::common::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::proto::common::Status* RetrieveResults::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveResults.status)
+  return status_;
+}
+inline void RetrieveResults::set_allocated_status(::milvus::proto::common::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.RetrieveResults.status)
+}
+
+// .milvus.proto.schema.IDs ids = 2;
+inline bool RetrieveResults::has_ids() const {
+  return this != internal_default_instance() && ids_ != nullptr;
+}
+inline const ::milvus::proto::schema::IDs& RetrieveResults::ids() const {
+  const ::milvus::proto::schema::IDs* p = ids_;
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveResults.ids)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::schema::IDs*>(
+      &::milvus::proto::schema::_IDs_default_instance_);
+}
+inline ::milvus::proto::schema::IDs* RetrieveResults::release_ids() {
+  // @@protoc_insertion_point(field_release:milvus.proto.milvus.RetrieveResults.ids)
+  
+  ::milvus::proto::schema::IDs* temp = ids_;
+  ids_ = nullptr;
+  return temp;
+}
+inline ::milvus::proto::schema::IDs* RetrieveResults::mutable_ids() {
+  
+  if (ids_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::proto::schema::IDs>(GetArenaNoVirtual());
+    ids_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveResults.ids)
+  return ids_;
+}
+inline void RetrieveResults::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.milvus.RetrieveResults.ids)
+}
+
+// repeated .milvus.proto.schema.FieldData fields_data = 3;
+inline int RetrieveResults::fields_data_size() const {
+  return fields_data_.size();
+}
+inline ::milvus::proto::schema::FieldData* RetrieveResults::mutable_fields_data(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RetrieveResults.fields_data)
+  return fields_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >*
+RetrieveResults::mutable_fields_data() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.RetrieveResults.fields_data)
+  return &fields_data_;
+}
+inline const ::milvus::proto::schema::FieldData& RetrieveResults::fields_data(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.RetrieveResults.fields_data)
+  return fields_data_.Get(index);
+}
+inline ::milvus::proto::schema::FieldData* RetrieveResults::add_fields_data() {
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.RetrieveResults.fields_data)
+  return fields_data_.Add();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >&
+RetrieveResults::fields_data() const {
+  // @@protoc_insertion_point(field_list:milvus.proto.milvus.RetrieveResults.fields_data)
+  return fields_data_;
+}
+
+// -------------------------------------------------------------------
+
 // Hits
 
 // repeated int64 IDs = 1;
@@ -16299,6 +17119,10 @@ inline void RegisterLinkResponse::set_allocated_status(::milvus::proto::common::
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 

internal/distributed/proxynode/service.go

@@ -379,6 +379,10 @@ func (s *Server) Search(ctx context.Context, request *milvuspb.SearchRequest) (*
 	return s.proxynode.Search(ctx, request)
 }
 
+func (s *Server) Retrieve(ctx context.Context, request *milvuspb.RetrieveRequest) (*milvuspb.RetrieveResults, error) {
+	return s.proxynode.Retrieve(ctx, request)
+}
+
 func (s *Server) Flush(ctx context.Context, request *milvuspb.FlushRequest) (*commonpb.Status, error) {
 	return s.proxynode.Flush(ctx, request)
 }

internal/proto/internal.proto

@@ -3,6 +3,7 @@ package milvus.proto.internal;
 option go_package = "github.com/milvus-io/milvus/internal/proto/internalpb";
 
 import "common.proto";
+import "schema.proto";
 
 enum StateCode {
   Initializing = 0;
@@ -63,7 +64,7 @@ message CreateCollectionRequest {
   int64 collectionID = 5;
   bytes schema = 6;
   repeated string virtualChannelNames = 7;
-  repeated string physicalChannelNames= 8;
+  repeated string physicalChannelNames = 8;
 }
 
 message DropCollectionRequest {
@@ -141,6 +142,24 @@ message SearchResults {
   repeated bytes hits = 5;
 }
 
+message RetrieveRequest {
+  common.MsgBase base = 1;
+  string result_channelID = 2;
+  int64 dbID = 3;
+  int64 collectionID = 4;
+  repeated int64 partitionIDs = 5;
+  schema.IDs ids = 6;
+  repeated string output_fields = 7;
+}
+
+message RetrieveResults {
+  common.MsgBase base = 1;
+  common.Status status = 2;
+  string result_channelID = 3;
+  schema.IDs ids = 4;
+  repeated schema.FieldData fields_data = 5;
+}
+
 message DeleteRequest {
   common.MsgBase base = 1;
   string collection_name = 2;

internal/proto/internalpb/internal.pb.go

@@ -7,6 +7,7 @@ import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	commonpb "github.com/milvus-io/milvus/internal/proto/commonpb"
+	schemapb "github.com/milvus-io/milvus/internal/proto/schemapb"
 	math "math"
 )
 
@@ -1209,6 +1210,164 @@ func (m *SearchResults) GetHits() [][]byte {
 	return nil
 }
 
+type RetrieveRequest struct {
+	Base                 *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	ResultChannelID      string            `protobuf:"bytes,2,opt,name=result_channelID,json=resultChannelID,proto3" json:"result_channelID,omitempty"`
+	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"`
+	OutputFields         []string          `protobuf:"bytes,7,rep,name=output_fields,json=outputFields,proto3" json:"output_fields,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_41f4a519b878ee3b, []int{18}
+}
+
+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) GetBase() *commonpb.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *RetrieveRequest) GetResultChannelID() string {
+	if m != nil {
+		return m.ResultChannelID
+	}
+	return ""
+}
+
+func (m *RetrieveRequest) GetDbID() int64 {
+	if m != nil {
+		return m.DbID
+	}
+	return 0
+}
+
+func (m *RetrieveRequest) GetCollectionID() int64 {
+	if m != nil {
+		return m.CollectionID
+	}
+	return 0
+}
+
+func (m *RetrieveRequest) GetPartitionIDs() []int64 {
+	if m != nil {
+		return m.PartitionIDs
+	}
+	return nil
+}
+
+func (m *RetrieveRequest) GetIds() *schemapb.IDs {
+	if m != nil {
+		return m.Ids
+	}
+	return nil
+}
+
+func (m *RetrieveRequest) GetOutputFields() []string {
+	if m != nil {
+		return m.OutputFields
+	}
+	return nil
+}
+
+type RetrieveResults struct {
+	Base                 *commonpb.MsgBase     `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	Status               *commonpb.Status      `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
+	ResultChannelID      string                `protobuf:"bytes,3,opt,name=result_channelID,json=resultChannelID,proto3" json:"result_channelID,omitempty"`
+	Ids                  *schemapb.IDs         `protobuf:"bytes,4,opt,name=ids,proto3" json:"ids,omitempty"`
+	FieldsData           []*schemapb.FieldData `protobuf:"bytes,5,rep,name=fields_data,json=fieldsData,proto3" json:"fields_data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+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_41f4a519b878ee3b, []int{19}
+}
+
+func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RetrieveResults.Unmarshal(m, b)
+}
+func (m *RetrieveResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RetrieveResults.Marshal(b, m, deterministic)
+}
+func (m *RetrieveResults) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RetrieveResults.Merge(m, src)
+}
+func (m *RetrieveResults) XXX_Size() int {
+	return xxx_messageInfo_RetrieveResults.Size(m)
+}
+func (m *RetrieveResults) XXX_DiscardUnknown() {
+	xxx_messageInfo_RetrieveResults.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RetrieveResults proto.InternalMessageInfo
+
+func (m *RetrieveResults) GetBase() *commonpb.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *RetrieveResults) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *RetrieveResults) GetResultChannelID() string {
+	if m != nil {
+		return m.ResultChannelID
+	}
+	return ""
+}
+
+func (m *RetrieveResults) GetIds() *schemapb.IDs {
+	if m != nil {
+		return m.Ids
+	}
+	return nil
+}
+
+func (m *RetrieveResults) GetFieldsData() []*schemapb.FieldData {
+	if m != nil {
+		return m.FieldsData
+	}
+	return nil
+}
+
 type DeleteRequest struct {
 	Base                 *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
 	CollectionName       string            `protobuf:"bytes,2,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
@@ -1224,7 +1383,7 @@ func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
 func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteRequest) ProtoMessage()    {}
 func (*DeleteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{18}
+	return fileDescriptor_41f4a519b878ee3b, []int{20}
 }
 
 func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
@@ -1296,7 +1455,7 @@ func (m *LoadIndex) Reset()         { *m = LoadIndex{} }
 func (m *LoadIndex) String() string { return proto.CompactTextString(m) }
 func (*LoadIndex) ProtoMessage()    {}
 func (*LoadIndex) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{19}
+	return fileDescriptor_41f4a519b878ee3b, []int{21}
 }
 
 func (m *LoadIndex) XXX_Unmarshal(b []byte) error {
@@ -1376,7 +1535,7 @@ func (m *SegmentStatisticsUpdates) Reset()         { *m = SegmentStatisticsUpdat
 func (m *SegmentStatisticsUpdates) String() string { return proto.CompactTextString(m) }
 func (*SegmentStatisticsUpdates) ProtoMessage()    {}
 func (*SegmentStatisticsUpdates) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{20}
+	return fileDescriptor_41f4a519b878ee3b, []int{22}
 }
 
 func (m *SegmentStatisticsUpdates) XXX_Unmarshal(b []byte) error {
@@ -1458,7 +1617,7 @@ func (m *SegmentStatistics) Reset()         { *m = SegmentStatistics{} }
 func (m *SegmentStatistics) String() string { return proto.CompactTextString(m) }
 func (*SegmentStatistics) ProtoMessage()    {}
 func (*SegmentStatistics) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{21}
+	return fileDescriptor_41f4a519b878ee3b, []int{23}
 }
 
 func (m *SegmentStatistics) XXX_Unmarshal(b []byte) error {
@@ -1505,7 +1664,7 @@ func (m *SegmentFlushCompletedMsg) Reset()         { *m = SegmentFlushCompletedM
 func (m *SegmentFlushCompletedMsg) String() string { return proto.CompactTextString(m) }
 func (*SegmentFlushCompletedMsg) ProtoMessage()    {}
 func (*SegmentFlushCompletedMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{22}
+	return fileDescriptor_41f4a519b878ee3b, []int{24}
 }
 
 func (m *SegmentFlushCompletedMsg) XXX_Unmarshal(b []byte) error {
@@ -1552,7 +1711,7 @@ func (m *IndexStats) Reset()         { *m = IndexStats{} }
 func (m *IndexStats) String() string { return proto.CompactTextString(m) }
 func (*IndexStats) ProtoMessage()    {}
 func (*IndexStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{23}
+	return fileDescriptor_41f4a519b878ee3b, []int{25}
 }
 
 func (m *IndexStats) XXX_Unmarshal(b []byte) error {
@@ -1600,7 +1759,7 @@ func (m *FieldStats) Reset()         { *m = FieldStats{} }
 func (m *FieldStats) String() string { return proto.CompactTextString(m) }
 func (*FieldStats) ProtoMessage()    {}
 func (*FieldStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{24}
+	return fileDescriptor_41f4a519b878ee3b, []int{26}
 }
 
 func (m *FieldStats) XXX_Unmarshal(b []byte) error {
@@ -1656,7 +1815,7 @@ func (m *SegmentStats) Reset()         { *m = SegmentStats{} }
 func (m *SegmentStats) String() string { return proto.CompactTextString(m) }
 func (*SegmentStats) ProtoMessage()    {}
 func (*SegmentStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{25}
+	return fileDescriptor_41f4a519b878ee3b, []int{27}
 }
 
 func (m *SegmentStats) XXX_Unmarshal(b []byte) error {
@@ -1718,7 +1877,7 @@ func (m *QueryNodeStats) Reset()         { *m = QueryNodeStats{} }
 func (m *QueryNodeStats) String() string { return proto.CompactTextString(m) }
 func (*QueryNodeStats) ProtoMessage()    {}
 func (*QueryNodeStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{26}
+	return fileDescriptor_41f4a519b878ee3b, []int{28}
 }
 
 func (m *QueryNodeStats) XXX_Unmarshal(b []byte) error {
@@ -1774,7 +1933,7 @@ func (m *MsgPosition) Reset()         { *m = MsgPosition{} }
 func (m *MsgPosition) String() string { return proto.CompactTextString(m) }
 func (*MsgPosition) ProtoMessage()    {}
 func (*MsgPosition) Descriptor() ([]byte, []int) {
-	return fileDescriptor_41f4a519b878ee3b, []int{27}
+	return fileDescriptor_41f4a519b878ee3b, []int{29}
 }
 
 func (m *MsgPosition) XXX_Unmarshal(b []byte) error {
@@ -1843,6 +2002,8 @@ func init() {
 	proto.RegisterType((*InsertRequest)(nil), "milvus.proto.internal.InsertRequest")
 	proto.RegisterType((*SearchRequest)(nil), "milvus.proto.internal.SearchRequest")
 	proto.RegisterType((*SearchResults)(nil), "milvus.proto.internal.SearchResults")
+	proto.RegisterType((*RetrieveRequest)(nil), "milvus.proto.internal.RetrieveRequest")
+	proto.RegisterType((*RetrieveResults)(nil), "milvus.proto.internal.RetrieveResults")
 	proto.RegisterType((*DeleteRequest)(nil), "milvus.proto.internal.DeleteRequest")
 	proto.RegisterType((*LoadIndex)(nil), "milvus.proto.internal.LoadIndex")
 	proto.RegisterType((*SegmentStatisticsUpdates)(nil), "milvus.proto.internal.SegmentStatisticsUpdates")
@@ -1858,104 +2019,110 @@ func init() {
 func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
 
 var fileDescriptor_41f4a519b878ee3b = []byte{
-	// 1576 bytes of a gzipped FileDescriptorProto
+	// 1667 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4d, 0x6f, 0x1b, 0xc5,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcb, 0x6f, 0x1c, 0x49,
-	0x1b, 0xff, 0xaf, 0xed, 0xc4, 0xf6, 0xe3, 0x4d, 0xea, 0x4e, 0xd3, 0x76, 0xd3, 0x97, 0x7f, 0xdd,
+	0x19, 0xa7, 0x67, 0xc6, 0x9e, 0x99, 0xaf, 0xdb, 0xf6, 0xa4, 0xe2, 0xec, 0xb6, 0x93, 0xec, 0xee,
-	0xfd, 0xbf, 0x10, 0xa8, 0x48, 0xaa, 0x14, 0x28, 0xe2, 0xd2, 0x36, 0x71, 0x1b, 0xac, 0x36, 0x51,
+	0x6c, 0x2f, 0x0f, 0xb3, 0x2b, 0xec, 0xc8, 0x0b, 0x04, 0x71, 0x49, 0x62, 0x4f, 0x62, 0x46, 0x89,
-	0x58, 0xb7, 0x95, 0xe0, 0xb2, 0x1a, 0xef, 0x4e, 0xec, 0x6d, 0xf7, 0x8d, 0x99, 0x71, 0x13, 0xf7,
+	0x2d, 0xd3, 0x93, 0x44, 0x82, 0x4b, 0xab, 0xa6, 0xbb, 0x3c, 0xd3, 0x49, 0xbf, 0xa8, 0xaa, 0xb6,
-	0xc4, 0x81, 0x1b, 0x82, 0x03, 0x12, 0x5f, 0x83, 0x8f, 0x00, 0xa8, 0x27, 0x24, 0xee, 0x48, 0x7c,
+	0x3d, 0x39, 0x71, 0xe0, 0x86, 0x40, 0x08, 0x89, 0x13, 0xff, 0x03, 0x7f, 0x02, 0xa0, 0x9c, 0x90,
-	0x0d, 0x8e, 0x9c, 0xd0, 0xbc, 0xec, 0xda, 0x4e, 0x37, 0x21, 0x35, 0x42, 0x08, 0xc1, 0x6d, 0xe7,
+	0xb8, 0x23, 0xf1, 0x6f, 0x70, 0xe4, 0x84, 0xea, 0xd1, 0x3d, 0x33, 0x4e, 0xdb, 0x4c, 0x1c, 0x21,
-	0x79, 0x9e, 0x79, 0x66, 0x7e, 0xbf, 0xe7, 0x65, 0x66, 0x16, 0x16, 0x83, 0x98, 0x13, 0x1a, 0xe3,
+	0x88, 0xd8, 0x5b, 0xd7, 0xf7, 0x7d, 0xf5, 0xf8, 0xfd, 0xbe, 0x57, 0x55, 0xc3, 0x6a, 0x98, 0x70,
-	0x70, 0x35, 0xa5, 0x09, 0x4f, 0xd0, 0xd9, 0x28, 0x08, 0x9f, 0x0d, 0x99, 0x1a, 0xad, 0x66, 0xca,
+	0x42, 0x13, 0x1c, 0x6d, 0x65, 0x34, 0xe5, 0x29, 0xba, 0x11, 0x87, 0xd1, 0x49, 0xce, 0xd4, 0x68,
-	0x0b, 0xa6, 0x97, 0x44, 0x51, 0x12, 0x2b, 0xb1, 0xfd, 0x8d, 0x01, 0x0b, 0x9b, 0x49, 0x94, 0x26,
+	0xab, 0x50, 0xde, 0xb4, 0xfc, 0x34, 0x8e, 0xd3, 0x44, 0x89, 0x6f, 0x5a, 0xcc, 0x1f, 0x93, 0x18,
-	0x31, 0x89, 0x79, 0x27, 0xde, 0x4b, 0xd0, 0x39, 0x98, 0x8f, 0x13, 0x9f, 0x74, 0xda, 0x96, 0xd1,
+	0xab, 0x91, 0xf3, 0x47, 0x03, 0x56, 0xf6, 0xd2, 0x38, 0x4b, 0x13, 0x92, 0xf0, 0x7e, 0x72, 0x9c,
-	0x32, 0x56, 0xca, 0x8e, 0x1e, 0x21, 0x04, 0x15, 0x9a, 0x84, 0xc4, 0x2a, 0xb5, 0x8c, 0x95, 0xba,
+	0xa2, 0x0f, 0x60, 0x39, 0x49, 0x03, 0xd2, 0xef, 0xd9, 0x46, 0xd7, 0xd8, 0xac, 0xbb, 0x7a, 0x84,
-	0x23, 0xbf, 0xd1, 0x2d, 0x00, 0xc6, 0x31, 0x27, 0xae, 0x97, 0xf8, 0xc4, 0x2a, 0xb7, 0x8c, 0x95,
+	0x10, 0x34, 0x68, 0x1a, 0x11, 0xbb, 0xd6, 0x35, 0x36, 0xdb, 0xae, 0xfc, 0x46, 0xf7, 0x00, 0x18,
-	0xc5, 0xf5, 0xd6, 0x6a, 0xe1, 0xba, 0xab, 0x5d, 0x61, 0xb8, 0x99, 0xf8, 0xc4, 0xa9, 0xb3, 0xec,
+	0xc7, 0x9c, 0x78, 0x7e, 0x1a, 0x10, 0xbb, 0xde, 0x35, 0x36, 0x57, 0x77, 0xba, 0x5b, 0x95, 0xa7,
-	0x13, 0xdd, 0x06, 0x20, 0x07, 0x9c, 0x62, 0x37, 0x88, 0xf7, 0x12, 0xab, 0xd2, 0x2a, 0xaf, 0x34,
+	0xd8, 0x1a, 0x08, 0xc3, 0xbd, 0x34, 0x20, 0x6e, 0x9b, 0x15, 0x9f, 0xe8, 0x3e, 0x00, 0x39, 0xe3,
-	0xd6, 0xaf, 0x4e, 0x3b, 0xd0, 0xdb, 0xbd, 0x4f, 0x46, 0x8f, 0x71, 0x38, 0x24, 0xbb, 0x38, 0xa0,
+	0x14, 0x7b, 0x61, 0x72, 0x9c, 0xda, 0x8d, 0x6e, 0x7d, 0xd3, 0xdc, 0xf9, 0x74, 0x7e, 0x01, 0x7d,
-	0x4e, 0x5d, 0x4e, 0x12, 0xdb, 0xb5, 0x7f, 0x32, 0xe0, 0x54, 0x0e, 0x40, 0xae, 0xc1, 0xd0, 0x7b,
+	0xf8, 0xc7, 0x64, 0xf2, 0x1c, 0x47, 0x39, 0x39, 0xc2, 0x21, 0x75, 0xdb, 0x72, 0x92, 0x38, 0xae,
-	0x30, 0x27, 0x97, 0x90, 0x08, 0x1a, 0xeb, 0xff, 0x3d, 0x62, 0x47, 0x53, 0xb8, 0x1d, 0x35, 0x05,
+	0xf3, 0x77, 0x03, 0xd6, 0x4a, 0x00, 0x72, 0x0f, 0x86, 0x7e, 0x08, 0x4b, 0x72, 0x0b, 0x89, 0xc0,
-	0x3d, 0x82, 0x33, 0x6c, 0xd8, 0xf3, 0x32, 0x95, 0x2b, 0xa5, 0xcc, 0x2a, 0xc9, 0xad, 0x9d, 0xcc,
+	0xdc, 0xf9, 0xfa, 0x05, 0x27, 0x9a, 0xc3, 0xed, 0xaa, 0x29, 0xe8, 0x19, 0x5c, 0x67, 0xf9, 0xd0,
-	0x13, 0x9a, 0x74, 0xa0, 0xb7, 0x74, 0x03, 0xe6, 0x85, 0xa7, 0x21, 0x93, 0x2c, 0x35, 0xd6, 0x2f,
+	0x2f, 0x54, 0x9e, 0x94, 0x32, 0xbb, 0x26, 0x8f, 0xb6, 0xd8, 0x4a, 0x68, 0x76, 0x01, 0x7d, 0xa4,
-	0x16, 0x82, 0xec, 0x4a, 0x13, 0x47, 0x9b, 0xda, 0x17, 0x61, 0x79, 0x8b, 0xf0, 0x43, 0xe8, 0x1c,
+	0x2f, 0x61, 0x59, 0xac, 0x94, 0x33, 0xc9, 0x92, 0xb9, 0x73, 0xab, 0x12, 0xe4, 0x40, 0x9a, 0xb8,
-	0xf2, 0xf1, 0x90, 0x30, 0xae, 0x95, 0x0f, 0x83, 0x88, 0x3c, 0x0c, 0xbc, 0xa7, 0x9b, 0x03, 0x1c,
+	0xda, 0xd4, 0xb9, 0x05, 0x1b, 0xfb, 0x84, 0x9f, 0x43, 0xe7, 0x92, 0x9f, 0xe5, 0x84, 0x71, 0xad,
-	0xc7, 0x24, 0xcc, 0x94, 0x97, 0xe1, 0xe2, 0x16, 0x91, 0x13, 0x02, 0xc6, 0x03, 0x8f, 0x1d, 0x52,
+	0x7c, 0x1a, 0xc6, 0xe4, 0x69, 0xe8, 0xbf, 0xdc, 0x1b, 0xe3, 0x24, 0x21, 0x51, 0xa1, 0xfc, 0x08,
-	0x9f, 0x85, 0x33, 0x5b, 0x84, 0xb7, 0xfd, 0x43, 0xe2, 0xc7, 0x50, 0xdb, 0x11, 0xc1, 0x16, 0x69,
+	0x6e, 0xed, 0x13, 0x39, 0x21, 0x64, 0x3c, 0xf4, 0xd9, 0x39, 0xf5, 0x0d, 0xb8, 0xbe, 0x4f, 0x78,
-	0xf0, 0x0e, 0x54, 0xb1, 0xef, 0x53, 0xc2, 0x98, 0x66, 0xf1, 0x52, 0xe1, 0x8e, 0xef, 0x28, 0x1b,
+	0x2f, 0x38, 0x27, 0x7e, 0x0e, 0xad, 0x43, 0xe1, 0x6c, 0x11, 0x06, 0xdf, 0x87, 0x26, 0x0e, 0x02,
-	0x27, 0x33, 0x2e, 0x4a, 0x13, 0xfb, 0x09, 0x40, 0x27, 0x0e, 0xf8, 0x2e, 0xa6, 0x38, 0x62, 0x47,
+	0x4a, 0x18, 0xd3, 0x2c, 0xde, 0xae, 0x3c, 0xf1, 0x03, 0x65, 0xe3, 0x16, 0xc6, 0x55, 0x61, 0xe2,
-	0x26, 0x58, 0x1b, 0x4c, 0xc6, 0x31, 0xe5, 0x6e, 0x2a, 0xed, 0x34, 0xe5, 0x27, 0xc8, 0x86, 0x86,
+	0xbc, 0x00, 0xe8, 0x27, 0x21, 0x3f, 0xc2, 0x14, 0xc7, 0xec, 0xc2, 0x00, 0xeb, 0x81, 0xc5, 0x38,
-	0x9c, 0xa6, 0xbc, 0xdb, 0x1f, 0x02, 0x74, 0x39, 0x0d, 0xe2, 0xfe, 0x83, 0x80, 0x71, 0xb1, 0xd6,
+	0xa6, 0xdc, 0xcb, 0xa4, 0x9d, 0xa6, 0x7c, 0x81, 0x68, 0x30, 0xe5, 0x34, 0xb5, 0xba, 0xf3, 0x13,
-	0x33, 0x61, 0x27, 0x40, 0x94, 0x57, 0xea, 0x8e, 0x1e, 0x4d, 0x84, 0xa3, 0x74, 0xf2, 0x70, 0xdc,
+	0x80, 0x01, 0xa7, 0x61, 0x32, 0x7a, 0x12, 0x32, 0x2e, 0xf6, 0x3a, 0x11, 0x76, 0x02, 0x44, 0x7d,
-	0x82, 0x46, 0x46, 0xf7, 0x36, 0xeb, 0xa3, 0xeb, 0x50, 0xe9, 0x61, 0x46, 0x8e, 0xa5, 0x67, 0x9b,
+	0xb3, 0xed, 0xea, 0xd1, 0x8c, 0x3b, 0x6a, 0x8b, 0xbb, 0xe3, 0x1e, 0x98, 0x05, 0xdd, 0x07, 0x6c,
-	0xf5, 0x37, 0x30, 0x23, 0x8e, 0xb4, 0xb4, 0x5f, 0x94, 0xe0, 0xfc, 0x26, 0x25, 0x32, 0xf9, 0xc3,
+	0x84, 0xee, 0x40, 0x63, 0x88, 0x19, 0xb9, 0x94, 0x9e, 0x03, 0x36, 0xda, 0xc5, 0x8c, 0xb8, 0xd2,
-	0x90, 0x78, 0x3c, 0x48, 0x62, 0xcd, 0xfd, 0xab, 0x7b, 0x43, 0xe7, 0xa1, 0xea, 0xf7, 0xdc, 0x18,
+	0xd2, 0x79, 0x5d, 0x83, 0x0f, 0xf7, 0x28, 0x91, 0xc1, 0x1f, 0x45, 0xc4, 0xe7, 0x61, 0x9a, 0x68,
-	0x47, 0x19, 0xd9, 0xf3, 0x7e, 0x6f, 0x07, 0x47, 0x04, 0xfd, 0x1f, 0x16, 0xbd, 0xdc, 0xbf, 0x90,
+	0xee, 0xdf, 0x7e, 0x35, 0xf4, 0x21, 0x34, 0x83, 0xa1, 0x97, 0xe0, 0xb8, 0x20, 0x7b, 0x39, 0x18,
-	0xc8, 0x9c, 0xab, 0x3b, 0x87, 0xa4, 0x22, 0x54, 0x7e, 0xaf, 0xd3, 0xb6, 0x2a, 0x32, 0x0c, 0xf2,
+	0x1e, 0xe2, 0x98, 0xa0, 0x6f, 0xc2, 0xaa, 0x5f, 0xae, 0x2f, 0x24, 0x32, 0xe6, 0xda, 0xee, 0x39,
-	0x1b, 0xd9, 0x60, 0x8e, 0xad, 0x3a, 0x6d, 0x6b, 0x4e, 0xea, 0xa6, 0x64, 0x82, 0x54, 0xe6, 0x0d,
+	0xa9, 0x70, 0x55, 0x30, 0xec, 0xf7, 0xec, 0x86, 0x74, 0x83, 0xfc, 0x46, 0x0e, 0x58, 0x53, 0xab,
-	0x48, 0x84, 0xad, 0xf9, 0x96, 0xb1, 0x62, 0x3a, 0x7a, 0x84, 0xae, 0xc3, 0x99, 0x67, 0x01, 0xe5,
+	0x7e, 0xcf, 0x5e, 0x92, 0xba, 0x39, 0x99, 0x20, 0x55, 0xd5, 0x10, 0x7b, 0xb9, 0x6b, 0x6c, 0x5a,
-	0x43, 0x1c, 0xea, 0xbc, 0x12, 0xab, 0x30, 0xab, 0x2a, 0x99, 0x2f, 0x52, 0xa1, 0x75, 0x58, 0x4a,
+	0xae, 0x1e, 0xa1, 0x3b, 0x70, 0xfd, 0x24, 0xa4, 0x3c, 0xc7, 0x91, 0x8e, 0x2b, 0xb1, 0x0b, 0xb3,
-	0x07, 0x23, 0x16, 0x78, 0x87, 0xa6, 0xd4, 0xe4, 0x94, 0x42, 0x9d, 0xfd, 0xc2, 0x80, 0xb3, 0x6d,
+	0x9b, 0x92, 0xf9, 0x2a, 0x15, 0xda, 0x81, 0xf5, 0x6c, 0x3c, 0x61, 0xa1, 0x7f, 0x6e, 0x4a, 0x4b,
-	0x9a, 0xa4, 0x7f, 0x65, 0x0a, 0xed, 0xcf, 0x4b, 0x70, 0x4e, 0x65, 0xc2, 0x2e, 0xa6, 0x3c, 0xf8,
+	0x4e, 0xa9, 0xd4, 0x39, 0xaf, 0x0d, 0xb8, 0xd1, 0xa3, 0x69, 0xf6, 0x3e, 0x53, 0xe8, 0xfc, 0xaa,
-	0x83, 0x50, 0xbc, 0x06, 0xa7, 0xc6, 0xab, 0x2a, 0x83, 0x62, 0x18, 0xff, 0x83, 0xc5, 0x34, 0xdb,
+	0x06, 0x1f, 0xa8, 0x48, 0x38, 0xc2, 0x94, 0x87, 0xff, 0x21, 0x14, 0xdf, 0x82, 0xb5, 0xe9, 0xae,
-	0x87, 0xb2, 0xab, 0x48, 0xbb, 0x85, 0x5c, 0x3a, 0x85, 0x76, 0xee, 0x18, 0xb4, 0xf3, 0x05, 0x09,
+	0xca, 0xa0, 0x1a, 0xc6, 0x37, 0x60, 0x35, 0x2b, 0xce, 0xa1, 0xec, 0x1a, 0xd2, 0x6e, 0xa5, 0x94,
-	0xd3, 0x82, 0x46, 0xee, 0xa8, 0xd3, 0xb6, 0xaa, 0xd2, 0x64, 0x52, 0x64, 0x7f, 0x56, 0x82, 0x25,
+	0xce, 0xa1, 0x5d, 0xba, 0x04, 0xed, 0x72, 0x45, 0xc0, 0x74, 0xc1, 0x2c, 0x17, 0xea, 0xf7, 0xec,
-	0x11, 0xd4, 0x7f, 0xd8, 0x10, 0x6c, 0x7c, 0x5b, 0x02, 0xa4, 0xb2, 0xa3, 0x13, 0xfb, 0xe4, 0xe0,
+	0xa6, 0x34, 0x99, 0x15, 0x39, 0xbf, 0xac, 0xc1, 0xba, 0x70, 0xea, 0x57, 0x6c, 0x08, 0x36, 0xfe,
-	0xcf, 0xe4, 0xe2, 0x32, 0xc0, 0x5e, 0x40, 0x42, 0x7f, 0x92, 0x87, 0xba, 0x94, 0xfc, 0x2e, 0x0e,
+	0x54, 0x03, 0xa4, 0xa2, 0xa3, 0x9f, 0x04, 0xe4, 0xec, 0xbf, 0xc9, 0xc5, 0x47, 0x00, 0xc7, 0x21,
-	0x2c, 0xa8, 0x4a, 0x27, 0x39, 0xfe, 0x6c, 0x28, 0x4e, 0x01, 0x75, 0x23, 0xd0, 0xa7, 0x40, 0xed,
+	0x89, 0x82, 0x59, 0x1e, 0xda, 0x52, 0xf2, 0x4e, 0x1c, 0xd8, 0xd0, 0x94, 0x8b, 0x94, 0xf8, 0x8b,
-	0xc4, 0xa7, 0x80, 0x9c, 0xa6, 0x4f, 0x81, 0xaf, 0xcb, 0xb0, 0xd0, 0x89, 0x19, 0xa1, 0xfc, 0xef,
+	0xa1, 0xe8, 0x02, 0xea, 0x46, 0xa0, 0xbb, 0x40, 0x6b, 0xe1, 0x2e, 0x20, 0xa7, 0xe9, 0x2e, 0xf0,
-	0x9c, 0x48, 0xe8, 0x12, 0xd4, 0x19, 0xe9, 0x47, 0xe2, 0x62, 0xd2, 0xb6, 0x6a, 0x52, 0x3f, 0x16,
+	0x87, 0x3a, 0xac, 0xf4, 0x13, 0x46, 0x28, 0xff, 0x7f, 0x0e, 0x24, 0x74, 0x1b, 0xda, 0x8c, 0x8c,
-	0x08, 0xad, 0xa7, 0x3a, 0x6b, 0xa7, 0x6d, 0xd5, 0x55, 0x68, 0x73, 0x01, 0xfa, 0x37, 0x00, 0x0f,
+	0x62, 0x71, 0x31, 0xe9, 0xd9, 0x2d, 0xa9, 0x9f, 0x0a, 0x84, 0xd6, 0x57, 0x95, 0xb5, 0xdf, 0xb3,
-	0x22, 0xc2, 0x38, 0x8e, 0x52, 0x66, 0x41, 0xab, 0xbc, 0x52, 0x71, 0x26, 0x24, 0xe2, 0x14, 0xa0,
+	0xdb, 0xca, 0xb5, 0xa5, 0x00, 0x7d, 0x0c, 0xc0, 0xc3, 0x98, 0x30, 0x8e, 0xe3, 0x8c, 0xd9, 0xd0,
-	0xc9, 0x7e, 0xa7, 0xcd, 0xac, 0x46, 0xab, 0x2c, 0x8e, 0x71, 0x35, 0x42, 0x6f, 0x41, 0x8d, 0x26,
+	0xad, 0x6f, 0x36, 0xdc, 0x19, 0x89, 0xe8, 0x02, 0x34, 0x3d, 0xed, 0xf7, 0x98, 0x6d, 0x76, 0xeb,
-	0xfb, 0xae, 0x8f, 0x39, 0xb6, 0x4c, 0x19, 0xbc, 0xe5, 0x42, 0xb2, 0x37, 0xc2, 0xa4, 0xe7, 0x54,
+	0xa2, 0x8d, 0xab, 0x11, 0xfa, 0x2e, 0xb4, 0x68, 0x7a, 0xea, 0x05, 0x98, 0x63, 0xdb, 0x92, 0xce,
-	0x69, 0xb2, 0xdf, 0xc6, 0x1c, 0xdb, 0x3f, 0x97, 0x60, 0xa1, 0x4b, 0x30, 0xf5, 0x06, 0xb3, 0x07,
+	0xdb, 0xa8, 0x24, 0x7b, 0x37, 0x4a, 0x87, 0x6e, 0x93, 0xa6, 0xa7, 0x3d, 0xcc, 0xb1, 0xf3, 0x8f,
-	0xec, 0x75, 0x68, 0x52, 0xc2, 0x86, 0x21, 0x77, 0xc7, 0xb0, 0x54, 0xe4, 0x4e, 0x29, 0xf9, 0x66,
+	0x1a, 0xac, 0x0c, 0x08, 0xa6, 0xfe, 0xf8, 0xea, 0x0e, 0xfb, 0x36, 0x74, 0x28, 0x61, 0x79, 0xc4,
-	0x0e, 0x2e, 0xa3, 0xbc, 0x7c, 0x0c, 0xe5, 0x95, 0x02, 0xca, 0x6d, 0x30, 0x27, 0xf8, 0x65, 0xd6,
+	0xbd, 0x29, 0x2c, 0xe5, 0xb9, 0x35, 0x25, 0xdf, 0x2b, 0xc1, 0x15, 0x94, 0xd7, 0x2f, 0xa1, 0xbc,
-	0x9c, 0x84, 0x3e, 0x25, 0x43, 0x4d, 0x28, 0xfb, 0x2c, 0x94, 0x11, 0xab, 0x3b, 0xe2, 0x13, 0x5d,
+	0x51, 0x41, 0xb9, 0x03, 0xd6, 0x0c, 0xbf, 0xcc, 0x5e, 0x92, 0xd0, 0xe7, 0x64, 0xa8, 0x03, 0xf5,
-	0x83, 0xd3, 0x69, 0x88, 0x3d, 0x32, 0x48, 0x42, 0x9f, 0x50, 0xb7, 0x4f, 0x93, 0x61, 0x2a, 0xc3,
+	0x80, 0x45, 0xd2, 0x63, 0x6d, 0x57, 0x7c, 0xa2, 0x2f, 0xe0, 0x5a, 0x16, 0x61, 0x9f, 0x8c, 0xd3,
-	0x65, 0x3a, 0xcd, 0x09, 0xc5, 0x96, 0x90, 0xa3, 0x9b, 0x50, 0xf3, 0x59, 0xe8, 0xf2, 0x51, 0x4a,
+	0x28, 0x20, 0xd4, 0x1b, 0xd1, 0x34, 0xcf, 0xa4, 0xbb, 0x2c, 0xb7, 0x33, 0xa3, 0xd8, 0x17, 0x72,
-	0x64, 0xc8, 0x16, 0x8f, 0xc0, 0xde, 0x66, 0xe1, 0xc3, 0x51, 0x4a, 0x9c, 0xaa, 0xaf, 0x3e, 0xd0,
+	0x74, 0x17, 0x5a, 0x01, 0x8b, 0x3c, 0x3e, 0xc9, 0x88, 0x74, 0xd9, 0xea, 0x05, 0xd8, 0x7b, 0x2c,
-	0x75, 0x58, 0x62, 0x84, 0x06, 0x38, 0x0c, 0x9e, 0x13, 0xdf, 0x25, 0x07, 0x29, 0x75, 0xd3, 0x10,
+	0x7a, 0x3a, 0xc9, 0x88, 0xdb, 0x0c, 0xd4, 0x07, 0xba, 0x03, 0xeb, 0x8c, 0xd0, 0x10, 0x47, 0xe1,
-	0xc7, 0x32, 0xb2, 0xa6, 0x83, 0xc6, 0xba, 0xbb, 0x07, 0x29, 0xdd, 0x0d, 0x71, 0x6c, 0xff, 0x68,
+	0x2b, 0x12, 0x78, 0xe4, 0x2c, 0xa3, 0x5e, 0x16, 0xe1, 0x44, 0x7a, 0xd6, 0x72, 0xd1, 0x54, 0xf7,
-	0x8c, 0x49, 0x17, 0xfc, 0xb0, 0x19, 0x48, 0x9f, 0xe5, 0x26, 0x55, 0x18, 0xa9, 0x72, 0x71, 0xa4,
+	0xf0, 0x2c, 0xa3, 0x47, 0x11, 0x4e, 0x9c, 0xbf, 0x19, 0x53, 0xd2, 0x05, 0x3f, 0xec, 0x0a, 0xa4,
-	0xae, 0x40, 0x23, 0x22, 0x9c, 0x06, 0x9e, 0x62, 0x44, 0x15, 0x10, 0x28, 0x91, 0x84, 0x8d, 0xa0,
+	0x5f, 0xe5, 0x26, 0x55, 0xe9, 0xa9, 0x7a, 0xb5, 0xa7, 0x3e, 0x01, 0x33, 0x26, 0x9c, 0x86, 0xbe,
-	0x32, 0x08, 0xb8, 0x0a, 0x85, 0xe9, 0xc8, 0x6f, 0xfb, 0x07, 0x03, 0x16, 0xda, 0x24, 0x24, 0x9c,
+	0x62, 0x44, 0x25, 0x10, 0x28, 0x91, 0x84, 0x8d, 0xa0, 0x31, 0x0e, 0xb9, 0x72, 0x85, 0xe5, 0xca,
-	0xcc, 0x9e, 0x4d, 0x05, 0x55, 0x5e, 0x2a, 0xac, 0xf2, 0xa9, 0x32, 0x2a, 0x1f, 0x5f, 0x46, 0x95,
+	0x6f, 0xe7, 0xf7, 0x35, 0x58, 0x73, 0x85, 0x09, 0x39, 0x21, 0xef, 0x7d, 0x3c, 0x7d, 0x0e, 0xf5,
-	0x97, 0xca, 0xe8, 0x2a, 0x98, 0x29, 0x0d, 0x22, 0x4c, 0x47, 0xee, 0x53, 0x32, 0xca, 0x32, 0xaa,
+	0x30, 0x60, 0x32, 0x9e, 0xcc, 0x1d, 0x7b, 0xfe, 0xdc, 0xfa, 0x2d, 0xd7, 0xef, 0x31, 0x57, 0x18,
-	0xa1, 0x65, 0xf7, 0xc9, 0x88, 0xd9, 0xbf, 0x18, 0x50, 0x7f, 0x90, 0x60, 0x5f, 0x1e, 0x06, 0x33,
+	0xa1, 0xcf, 0x60, 0x25, 0xcd, 0x79, 0x96, 0x73, 0x4f, 0xd6, 0xd3, 0xe2, 0xf2, 0x65, 0x29, 0xe1,
-	0x20, 0x99, 0xea, 0x02, 0xa5, 0x82, 0x2e, 0x90, 0xf7, 0xf3, 0x6c, 0xfb, 0xe3, 0x06, 0x3f, 0xd1,
+	0x23, 0x29, 0x73, 0x7e, 0x33, 0xc7, 0xce, 0xff, 0xaa, 0xe3, 0x35, 0xec, 0xc6, 0x22, 0xb0, 0xef,
-	0xa8, 0x2b, 0xd3, 0x8d, 0xfa, 0x0a, 0x34, 0x02, 0xb1, 0x21, 0x37, 0xc5, 0x7c, 0xa0, 0xf6, 0x5d,
+	0x81, 0xa9, 0xf0, 0xaa, 0xb2, 0xb3, 0x24, 0xcb, 0xce, 0xc7, 0x95, 0x73, 0x24, 0x07, 0xa2, 0xe4,
-	0x77, 0x40, 0x8a, 0x76, 0x85, 0x44, 0x74, 0xf2, 0xcc, 0x40, 0x76, 0xf2, 0xf9, 0x13, 0x77, 0x72,
+	0xb8, 0xaa, 0xb1, 0x31, 0x59, 0x7e, 0xfe, 0x6a, 0xc0, 0x4a, 0x8f, 0x44, 0x84, 0xbf, 0x43, 0xb8,
-	0xed, 0x44, 0x76, 0xf2, 0xef, 0x4a, 0x60, 0x75, 0xd5, 0x66, 0xc7, 0xcf, 0x99, 0x47, 0xa9, 0x2f,
+	0x54, 0xb4, 0x85, 0x5a, 0x65, 0x5b, 0x98, 0xab, 0xbb, 0xf5, 0xcb, 0xeb, 0x6e, 0xe3, 0x8d, 0xba,
-	0x5f, 0x55, 0x97, 0xa0, 0xde, 0xcd, 0x91, 0xa9, 0xd7, 0xc4, 0x58, 0x20, 0xa8, 0xdf, 0x26, 0x51,
+	0xfb, 0x29, 0x58, 0x19, 0x0d, 0x63, 0x4c, 0x27, 0xde, 0x4b, 0x32, 0x29, 0x42, 0xc6, 0xd4, 0xb2,
-	0x42, 0x47, 0xdd, 0xe0, 0x39, 0xd1, 0xc0, 0x27, 0x24, 0x02, 0xdb, 0xce, 0x30, 0x72, 0x92, 0x7d,
+	0xc7, 0x64, 0xc2, 0x9c, 0x7f, 0x1a, 0xd0, 0x7e, 0x92, 0xe2, 0x40, 0xde, 0x1e, 0xae, 0x80, 0x64,
-	0xa6, 0xfb, 0x40, 0x36, 0x14, 0xd8, 0x3c, 0x79, 0xfe, 0xba, 0x22, 0x52, 0x12, 0x79, 0xc5, 0x01,
+	0xae, 0x6d, 0xd4, 0x2a, 0xda, 0x46, 0x79, 0x01, 0x28, 0x8e, 0x3f, 0xbd, 0x11, 0xcc, 0x74, 0xf6,
-	0x25, 0x12, 0x4f, 0x00, 0xb4, 0x0c, 0x35, 0x12, 0xfb, 0x4a, 0x3b, 0x27, 0xb5, 0x55, 0x12, 0xfb,
+	0xc6, 0x7c, 0x67, 0xff, 0x04, 0xcc, 0x50, 0x1c, 0xc8, 0xcb, 0x30, 0x1f, 0xab, 0x73, 0xb7, 0x5d,
-	0x52, 0xd5, 0x81, 0x45, 0xfd, 0x8c, 0x49, 0x98, 0xec, 0x09, 0xb2, 0x13, 0x34, 0xd6, 0xed, 0x23,
+	0x90, 0xa2, 0x23, 0x21, 0x11, 0xad, 0xbf, 0x30, 0x90, 0xad, 0x7f, 0x79, 0xe1, 0xd6, 0xaf, 0x17,
-	0xde, 0x8e, 0xdb, 0xac, 0xbf, 0xab, 0x2d, 0x9d, 0x05, 0xf5, 0x92, 0xd1, 0x43, 0x74, 0x17, 0x4c,
+	0x91, 0xad, 0xff, 0xcf, 0x35, 0xb0, 0x07, 0xea, 0xb0, 0xd3, 0xf7, 0xef, 0xb3, 0x2c, 0x90, 0xcf,
-	0xb1, 0x4a, 0xee, 0xa8, 0x7a, 0x62, 0x47, 0x0d, 0x12, 0xfb, 0xd9, 0xc0, 0xfe, 0xd2, 0x80, 0xd3,
+	0xf0, 0xdb, 0xd0, 0x1e, 0x94, 0xc8, 0xd4, 0xf3, 0x73, 0x2a, 0x10, 0xd4, 0x1f, 0x90, 0x38, 0xa5,
-	0x2f, 0x51, 0x38, 0x43, 0x1e, 0xdd, 0x87, 0x5a, 0x97, 0xf4, 0x85, 0x8b, 0xec, 0x71, 0xb6, 0x76,
+	0x93, 0x41, 0xf8, 0x8a, 0x68, 0xe0, 0x33, 0x12, 0x81, 0xed, 0x30, 0x8f, 0xdd, 0xf4, 0x94, 0xe9,
-	0xd4, 0x5b, 0xff, 0x88, 0x80, 0x39, 0xb9, 0x03, 0xfb, 0x49, 0x1e, 0xd6, 0x7b, 0xe1, 0x90, 0x0d,
+	0x44, 0x2f, 0x86, 0x02, 0x9b, 0x2f, 0x2f, 0x6c, 0x9e, 0xf0, 0x94, 0x44, 0xde, 0x70, 0x41, 0x89,
-	0xc4, 0x23, 0x57, 0xd4, 0xab, 0x3f, 0xd3, 0xcb, 0xea, 0xf8, 0x14, 0xb7, 0x3f, 0x35, 0xc4, 0x03,
+	0xc4, 0x9b, 0x11, 0x6d, 0x40, 0x8b, 0x24, 0x81, 0xd2, 0x2e, 0x49, 0x6d, 0x93, 0x24, 0x81, 0x54,
-	0xd4, 0x27, 0x07, 0x72, 0xe9, 0x97, 0x12, 0xd3, 0x98, 0x25, 0x31, 0x45, 0xbb, 0x8d, 0x87, 0x91,
+	0xf5, 0x61, 0x55, 0xbf, 0x7b, 0x53, 0x26, 0x93, 0x5e, 0xa7, 0xba, 0x73, 0xc1, 0xcf, 0x86, 0x03,
-	0x4b, 0x49, 0x88, 0x39, 0xf1, 0x5d, 0xbd, 0x1a, 0xd3, 0xab, 0xa3, 0x78, 0x18, 0x39, 0x4a, 0xa5,
+	0x36, 0x3a, 0xd2, 0x96, 0xee, 0x8a, 0x7a, 0xfa, 0xea, 0x21, 0x7a, 0x08, 0x96, 0xd8, 0xa5, 0x5c,
-	0x61, 0x32, 0xfb, 0x0b, 0x03, 0xe0, 0x9e, 0xa8, 0x1e, 0xb5, 0x8d, 0xc3, 0xe7, 0x8d, 0x71, 0xfc,
+	0xa8, 0xb9, 0xf0, 0x42, 0x26, 0x49, 0x82, 0x62, 0xe0, 0xfc, 0xd6, 0x80, 0x6b, 0x6f, 0x50, 0x78,
-	0x3d, 0xa9, 0x34, 0x5d, 0x7e, 0x1b, 0x59, 0xf9, 0x31, 0x19, 0x8f, 0x72, 0x11, 0x86, 0x3c, 0x1e,
+	0x85, 0x38, 0x7a, 0x0c, 0xad, 0x01, 0x19, 0x89, 0x25, 0x8a, 0xd7, 0xfc, 0xf6, 0x45, 0x3f, 0x87,
-	0x63, 0xf0, 0xba, 0x42, 0x55, 0x0c, 0xbe, 0x32, 0xc0, 0x9c, 0x08, 0x15, 0x9b, 0xa6, 0xd1, 0x38,
+	0x2e, 0x70, 0x98, 0x5b, 0x2e, 0xe0, 0xbc, 0x28, 0xdd, 0xfa, 0x28, 0xca, 0xd9, 0x78, 0x2f, 0x8d,
-	0xdc, 0x29, 0x64, 0x2b, 0x16, 0xd5, 0xe3, 0xb2, 0x89, 0x82, 0x8a, 0xc6, 0x05, 0xb5, 0x0c, 0x35,
+	0x33, 0x91, 0xaf, 0xc1, 0x95, 0x9e, 0xe2, 0x97, 0x87, 0xb8, 0xf3, 0x0b, 0x03, 0x40, 0x26, 0x8f,
-	0x49, 0xc9, 0x44, 0x45, 0xc5, 0xba, 0xa2, 0xae, 0xc1, 0x69, 0x4a, 0x3c, 0x12, 0xf3, 0x70, 0xe4,
+	0xdc, 0xfa, 0x8d, 0xc0, 0x34, 0xae, 0x12, 0x98, 0xa2, 0x3f, 0x27, 0x79, 0xec, 0x51, 0x12, 0x61,
-	0x46, 0x89, 0x1f, 0xec, 0x05, 0xc4, 0x97, 0x75, 0x55, 0x73, 0x9a, 0x99, 0x62, 0x5b, 0xcb, 0xed,
+	0x4e, 0x02, 0x4f, 0xef, 0xc6, 0xf4, 0xee, 0x28, 0xc9, 0x63, 0x57, 0xa9, 0x34, 0x4c, 0xe6, 0xfc,
-	0xef, 0x0d, 0x58, 0xfc, 0x60, 0x48, 0xe8, 0x68, 0x27, 0xf1, 0x89, 0xda, 0xd9, 0xab, 0xa7, 0xc4,
+	0xda, 0x00, 0x90, 0xf5, 0x4a, 0x1d, 0xe3, 0x7c, 0x43, 0x31, 0x2e, 0xbf, 0x58, 0xd7, 0xe6, 0xd3,
-	0x6d, 0x89, 0x45, 0xd3, 0xa3, 0xd2, 0xf5, 0x3f, 0xbf, 0x9d, 0xae, 0xcc, 0xa9, 0x31, 0x9d, 0xa2,
+	0x6f, 0xb7, 0x48, 0x3f, 0x26, 0xfd, 0x51, 0xaf, 0xc2, 0x50, 0xfa, 0x63, 0x0a, 0x5e, 0x67, 0xa8,
-	0x82, 0x62, 0x75, 0xf7, 0x3d, 0x09, 0xc5, 0xe3, 0xc0, 0x3a, 0xea, 0xc6, 0xac, 0x28, 0xfe, 0xc4,
+	0xf2, 0xc1, 0xef, 0x0c, 0xb0, 0x66, 0x5c, 0xc5, 0xe6, 0x69, 0x34, 0xce, 0x57, 0x0a, 0xd9, 0xbb,
-	0x80, 0xc6, 0x44, 0x61, 0x8a, 0x76, 0xaf, 0xcf, 0x06, 0x75, 0xa4, 0x18, 0xb2, 0xe1, 0x36, 0xbc,
+	0x45, 0xf6, 0x78, 0x6c, 0x26, 0xa1, 0xe2, 0x69, 0x42, 0x6d, 0x40, 0x4b, 0x52, 0x32, 0x93, 0x51,
-	0xf1, 0x0b, 0x17, 0x2d, 0xc1, 0x5c, 0xc4, 0xfa, 0x3a, 0xe2, 0xa6, 0xa3, 0x06, 0xe8, 0x02, 0xd4,
+	0x89, 0xce, 0xa8, 0x2f, 0xe0, 0x1a, 0x25, 0x3e, 0x49, 0x78, 0x34, 0xf1, 0xe2, 0x34, 0x08, 0x8f,
-	0x22, 0xd6, 0x97, 0x57, 0x04, 0xdd, 0xa5, 0xf3, 0xb1, 0x08, 0x5b, 0x7e, 0xa2, 0xe8, 0x66, 0x35,
+	0x43, 0x12, 0xc8, 0xbc, 0x6a, 0xb9, 0x9d, 0x42, 0x71, 0xa0, 0xe5, 0xce, 0x5f, 0x0c, 0x58, 0xfd,
-	0x16, 0xbc, 0xf1, 0x2e, 0xd4, 0xf3, 0x7f, 0x6f, 0xa8, 0x09, 0x66, 0x27, 0x0e, 0xb8, 0xbc, 0x09,
+	0x71, 0x4e, 0xe8, 0xe4, 0x30, 0x0d, 0x88, 0x3a, 0xd9, 0xdb, 0x87, 0xc4, 0x7d, 0x89, 0x45, 0xd3,
-	0x04, 0x71, 0xbf, 0xf9, 0x2f, 0xd4, 0x80, 0xea, 0xfb, 0x04, 0x87, 0x7c, 0x30, 0x6a, 0x1a, 0xc8,
+	0xa3, 0xc2, 0xf5, 0xb3, 0x7f, 0x1f, 0xae, 0xcc, 0x6d, 0x31, 0x1d, 0xa2, 0x82, 0x62, 0xf5, 0x58,
-	0x84, 0xda, 0x9d, 0x5e, 0x9c, 0xd0, 0x08, 0x87, 0xcd, 0xd2, 0xc6, 0xcd, 0x8f, 0xde, 0xee, 0x07,
+	0x5a, 0x84, 0xe2, 0xa9, 0x63, 0x75, 0x27, 0x52, 0x14, 0xff, 0xdc, 0x00, 0x73, 0x26, 0x31, 0x45,
-	0x7c, 0x30, 0xec, 0x09, 0x86, 0xd7, 0x14, 0xee, 0x37, 0x83, 0x44, 0x7f, 0xad, 0x65, 0xd8, 0xd7,
+	0xb9, 0xd7, 0xbd, 0x41, 0xb5, 0x14, 0x43, 0x16, 0x5c, 0xd3, 0x9f, 0xfe, 0x12, 0x41, 0xeb, 0xb0,
-	0x24, 0x15, 0xf9, 0x30, 0xed, 0xf5, 0xe6, 0xa5, 0xe4, 0xc6, 0xaf, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0x14, 0xb3, 0x91, 0xf6, 0xb8, 0xe5, 0xaa, 0x01, 0xba, 0x09, 0xad, 0x98, 0x8d, 0xe4, 0x9d, 0x52,
-	0x06, 0xd4, 0x73, 0xc8, 0x93, 0x14, 0x00, 0x00,
+	0x57, 0xe9, 0x72, 0x2c, 0xdc, 0x56, 0x76, 0x14, 0x5d, 0xac, 0xa6, 0x82, 0xcf, 0x7f, 0x00, 0xed,
+	0xf2, 0x67, 0x2d, 0xea, 0x80, 0xd5, 0x4f, 0x42, 0x2e, 0xaf, 0x8e, 0x61, 0x32, 0xea, 0x7c, 0x0d,
+	0x99, 0xd0, 0xfc, 0x11, 0xc1, 0x11, 0x1f, 0x4f, 0x3a, 0x06, 0xb2, 0xa0, 0xf5, 0x60, 0x98, 0xa4,
+	0x34, 0xc6, 0x51, 0xa7, 0xb6, 0x7b, 0xf7, 0xa7, 0xdf, 0x1b, 0x85, 0x7c, 0x9c, 0x0f, 0x05, 0xc3,
+	0xdb, 0x0a, 0xf7, 0x77, 0xc2, 0x54, 0x7f, 0x6d, 0x17, 0xd8, 0xb7, 0x25, 0x15, 0xe5, 0x30, 0x1b,
+	0x0e, 0x97, 0xa5, 0xe4, 0xcb, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x70, 0x63, 0x8f, 0xe1, 0xd2,
+	0x16, 0x00, 0x00,
 }

internal/proto/milvus.proto

@@ -32,6 +32,7 @@ service MilvusService {
 
   rpc Insert(InsertRequest) returns (InsertResponse) {}
   rpc Search(SearchRequest) returns (SearchResults) {}
+  rpc Retrieve(RetrieveRequest) returns (RetrieveResults) {}
   rpc Flush(FlushRequest) returns (common.Status) {}
 
   rpc GetPersistentSegmentInfo(GetPersistentSegmentInfoRequest) returns (GetPersistentSegmentInfoResponse) {}
@@ -314,6 +315,21 @@ message SearchRequest {
   repeated common.KeyValuePair search_params = 8;
 }
 
+message RetrieveRequest {
+  common.MsgBase base = 1;
+  string db_name = 2;
+  string collection_name = 3;
+  repeated string partition_names = 4;
+  schema.IDs ids = 5;
+  repeated string output_fields = 6;
+}
+
+message RetrieveResults {
+  common.Status status = 1;
+  schema.IDs ids = 2;
+  repeated schema.FieldData fields_data = 3;
+}
+
 message Hits {
   repeated int64 IDs = 1;
   repeated bytes row_data = 2;

internal/proto/milvuspb/milvus.pb.go

@@ -2449,6 +2449,140 @@ func (m *SearchRequest) GetSearchParams() []*commonpb.KeyValuePair {
 	return nil
 }
 
+type RetrieveRequest struct {
+	Base                 *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	DbName               string            `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
+	CollectionName       string            `protobuf:"bytes,3,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
+	PartitionNames       []string          `protobuf:"bytes,4,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
+	Ids                  *schemapb.IDs     `protobuf:"bytes,5,opt,name=ids,proto3" json:"ids,omitempty"`
+	OutputFields         []string          `protobuf:"bytes,6,rep,name=output_fields,json=outputFields,proto3" json:"output_fields,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_02345ba45cc0e303, []int{40}
+}
+
+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) GetBase() *commonpb.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *RetrieveRequest) GetDbName() string {
+	if m != nil {
+		return m.DbName
+	}
+	return ""
+}
+
+func (m *RetrieveRequest) GetCollectionName() string {
+	if m != nil {
+		return m.CollectionName
+	}
+	return ""
+}
+
+func (m *RetrieveRequest) GetPartitionNames() []string {
+	if m != nil {
+		return m.PartitionNames
+	}
+	return nil
+}
+
+func (m *RetrieveRequest) GetIds() *schemapb.IDs {
+	if m != nil {
+		return m.Ids
+	}
+	return nil
+}
+
+func (m *RetrieveRequest) GetOutputFields() []string {
+	if m != nil {
+		return m.OutputFields
+	}
+	return nil
+}
+
+type RetrieveResults struct {
+	Status               *commonpb.Status      `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	Ids                  *schemapb.IDs         `protobuf:"bytes,2,opt,name=ids,proto3" json:"ids,omitempty"`
+	FieldsData           []*schemapb.FieldData `protobuf:"bytes,3,rep,name=fields_data,json=fieldsData,proto3" json:"fields_data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+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_02345ba45cc0e303, []int{41}
+}
+
+func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RetrieveResults.Unmarshal(m, b)
+}
+func (m *RetrieveResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RetrieveResults.Marshal(b, m, deterministic)
+}
+func (m *RetrieveResults) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RetrieveResults.Merge(m, src)
+}
+func (m *RetrieveResults) XXX_Size() int {
+	return xxx_messageInfo_RetrieveResults.Size(m)
+}
+func (m *RetrieveResults) XXX_DiscardUnknown() {
+	xxx_messageInfo_RetrieveResults.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RetrieveResults proto.InternalMessageInfo
+
+func (m *RetrieveResults) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *RetrieveResults) GetIds() *schemapb.IDs {
+	if m != nil {
+		return m.Ids
+	}
+	return nil
+}
+
+func (m *RetrieveResults) GetFieldsData() []*schemapb.FieldData {
+	if m != nil {
+		return m.FieldsData
+	}
+	return nil
+}
+
 type Hits struct {
 	IDs                  []int64   `protobuf:"varint,1,rep,packed,name=IDs,proto3" json:"IDs,omitempty"`
 	RowData              [][]byte  `protobuf:"bytes,2,rep,name=row_data,json=rowData,proto3" json:"row_data,omitempty"`
@@ -2462,7 +2596,7 @@ func (m *Hits) Reset()         { *m = Hits{} }
 func (m *Hits) String() string { return proto.CompactTextString(m) }
 func (*Hits) ProtoMessage()    {}
 func (*Hits) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{40}
+	return fileDescriptor_02345ba45cc0e303, []int{42}
 }
 
 func (m *Hits) XXX_Unmarshal(b []byte) error {
@@ -2516,7 +2650,7 @@ func (m *SearchResults) Reset()         { *m = SearchResults{} }
 func (m *SearchResults) String() string { return proto.CompactTextString(m) }
 func (*SearchResults) ProtoMessage()    {}
 func (*SearchResults) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{41}
+	return fileDescriptor_02345ba45cc0e303, []int{43}
 }
 
 func (m *SearchResults) XXX_Unmarshal(b []byte) error {
@@ -2564,7 +2698,7 @@ func (m *FlushRequest) Reset()         { *m = FlushRequest{} }
 func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
 func (*FlushRequest) ProtoMessage()    {}
 func (*FlushRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{42}
+	return fileDescriptor_02345ba45cc0e303, []int{44}
 }
 
 func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
@@ -2625,7 +2759,7 @@ func (m *PersistentSegmentInfo) Reset()         { *m = PersistentSegmentInfo{} }
 func (m *PersistentSegmentInfo) String() string { return proto.CompactTextString(m) }
 func (*PersistentSegmentInfo) ProtoMessage()    {}
 func (*PersistentSegmentInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{43}
+	return fileDescriptor_02345ba45cc0e303, []int{45}
 }
 
 func (m *PersistentSegmentInfo) XXX_Unmarshal(b []byte) error {
@@ -2722,7 +2856,7 @@ func (m *GetPersistentSegmentInfoRequest) Reset()         { *m = GetPersistentSe
 func (m *GetPersistentSegmentInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*GetPersistentSegmentInfoRequest) ProtoMessage()    {}
 func (*GetPersistentSegmentInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{44}
+	return fileDescriptor_02345ba45cc0e303, []int{46}
 }
 
 func (m *GetPersistentSegmentInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -2776,7 +2910,7 @@ func (m *GetPersistentSegmentInfoResponse) Reset()         { *m = GetPersistentS
 func (m *GetPersistentSegmentInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*GetPersistentSegmentInfoResponse) ProtoMessage()    {}
 func (*GetPersistentSegmentInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{45}
+	return fileDescriptor_02345ba45cc0e303, []int{47}
 }
 
 func (m *GetPersistentSegmentInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -2828,7 +2962,7 @@ func (m *QuerySegmentInfo) Reset()         { *m = QuerySegmentInfo{} }
 func (m *QuerySegmentInfo) String() string { return proto.CompactTextString(m) }
 func (*QuerySegmentInfo) ProtoMessage()    {}
 func (*QuerySegmentInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{46}
+	return fileDescriptor_02345ba45cc0e303, []int{48}
 }
 
 func (m *QuerySegmentInfo) XXX_Unmarshal(b []byte) error {
@@ -2911,7 +3045,7 @@ func (m *GetQuerySegmentInfoRequest) Reset()         { *m = GetQuerySegmentInfoR
 func (m *GetQuerySegmentInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*GetQuerySegmentInfoRequest) ProtoMessage()    {}
 func (*GetQuerySegmentInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{47}
+	return fileDescriptor_02345ba45cc0e303, []int{49}
 }
 
 func (m *GetQuerySegmentInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -2965,7 +3099,7 @@ func (m *GetQuerySegmentInfoResponse) Reset()         { *m = GetQuerySegmentInfo
 func (m *GetQuerySegmentInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*GetQuerySegmentInfoResponse) ProtoMessage()    {}
 func (*GetQuerySegmentInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{48}
+	return fileDescriptor_02345ba45cc0e303, []int{50}
 }
 
 func (m *GetQuerySegmentInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -3010,7 +3144,7 @@ func (m *RegisterLinkRequest) Reset()         { *m = RegisterLinkRequest{} }
 func (m *RegisterLinkRequest) String() string { return proto.CompactTextString(m) }
 func (*RegisterLinkRequest) ProtoMessage()    {}
 func (*RegisterLinkRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{49}
+	return fileDescriptor_02345ba45cc0e303, []int{51}
 }
 
 func (m *RegisterLinkRequest) XXX_Unmarshal(b []byte) error {
@@ -3043,7 +3177,7 @@ func (m *RegisterLinkResponse) Reset()         { *m = RegisterLinkResponse{} }
 func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) }
 func (*RegisterLinkResponse) ProtoMessage()    {}
 func (*RegisterLinkResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{50}
+	return fileDescriptor_02345ba45cc0e303, []int{52}
 }
 
 func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error {
@@ -3120,6 +3254,8 @@ func init() {
 	proto.RegisterType((*PlaceholderValue)(nil), "milvus.proto.milvus.PlaceholderValue")
 	proto.RegisterType((*PlaceholderGroup)(nil), "milvus.proto.milvus.PlaceholderGroup")
 	proto.RegisterType((*SearchRequest)(nil), "milvus.proto.milvus.SearchRequest")
+	proto.RegisterType((*RetrieveRequest)(nil), "milvus.proto.milvus.RetrieveRequest")
+	proto.RegisterType((*RetrieveResults)(nil), "milvus.proto.milvus.RetrieveResults")
 	proto.RegisterType((*Hits)(nil), "milvus.proto.milvus.Hits")
 	proto.RegisterType((*SearchResults)(nil), "milvus.proto.milvus.SearchResults")
 	proto.RegisterType((*FlushRequest)(nil), "milvus.proto.milvus.FlushRequest")
@@ -3136,144 +3272,151 @@ func init() {
 func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
 
 var fileDescriptor_02345ba45cc0e303 = []byte{
-	// 2184 bytes of a gzipped FileDescriptorProto
+	// 2292 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x5d, 0x6f, 0x1b, 0x59,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcd, 0x6f, 0x1c, 0x49,
-	0xb5, 0xd7, 0x5f, 0xb1, 0x8f, 0xed, 0xc4, 0x7b, 0xf3, 0xe5, 0xb8, 0xed, 0xd6, 0x19, 0x28, 0x9b,
+	0x15, 0x4f, 0xcd, 0x97, 0x67, 0xde, 0xf4, 0xd8, 0xb3, 0xe5, 0x8f, 0x4c, 0x26, 0x5f, 0xe3, 0xde,
-	0xb6, 0xbb, 0xcd, 0x92, 0xb4, 0x2c, 0x08, 0x81, 0x20, 0x0d, 0x4d, 0xa3, 0xee, 0x56, 0xd9, 0x71,
+	0x0d, 0xeb, 0x24, 0xbb, 0xf1, 0x62, 0x27, 0x2c, 0x08, 0xf1, 0xe5, 0x98, 0x38, 0x56, 0x76, 0x23,
-	0x59, 0xb1, 0xac, 0x2a, 0x6b, 0xec, 0xb9, 0x8d, 0x47, 0x1d, 0xcf, 0x98, 0xb9, 0xe3, 0xa4, 0xee,
+	0x6f, 0x4f, 0x58, 0xed, 0xb2, 0x8a, 0x46, 0x3d, 0xd3, 0x15, 0x4f, 0x2b, 0x3d, 0xdd, 0x43, 0x57,
-	0x13, 0x62, 0x11, 0x12, 0x02, 0xba, 0x48, 0x20, 0x24, 0x78, 0xe0, 0x01, 0x69, 0x1f, 0x78, 0x02,
+	0x8f, 0x9d, 0xc9, 0x09, 0xb1, 0x08, 0x09, 0x01, 0xd9, 0x03, 0x08, 0x09, 0x0e, 0x1c, 0x90, 0xf6,
-	0x04, 0x12, 0x12, 0xcf, 0xfb, 0x80, 0xc4, 0x0b, 0xe2, 0x3f, 0xf0, 0x06, 0x3f, 0x01, 0x09, 0xdd,
+	0xc0, 0x09, 0xd0, 0x22, 0x21, 0x71, 0xde, 0x03, 0x12, 0x17, 0xc4, 0xff, 0xc0, 0x05, 0xc1, 0x9f,
-	0x0f, 0x8f, 0x67, 0x26, 0x77, 0x1c, 0xa7, 0xde, 0x6e, 0x92, 0xb7, 0x99, 0x33, 0xe7, 0xdc, 0x7b,
+	0x80, 0x40, 0x55, 0xd5, 0xdd, 0xd3, 0xdd, 0xae, 0x1e, 0x8f, 0x33, 0x9b, 0xb5, 0x7d, 0xeb, 0x7e,
-	0xbe, 0xef, 0xb9, 0xe7, 0x0c, 0x94, 0xba, 0x96, 0x7d, 0xd0, 0xa7, 0x37, 0x7b, 0x9e, 0xeb, 0xbb,
+	0xfd, 0xaa, 0xea, 0x57, 0xef, 0xab, 0xde, 0xab, 0xd7, 0xa0, 0xf4, 0x4c, 0x6b, 0x6f, 0x40, 0x6f,
-	0x78, 0x3e, 0xfc, 0x76, 0x53, 0xbc, 0xd4, 0x4a, 0x6d, 0xb7, 0xdb, 0x75, 0x1d, 0x01, 0xac, 0x95,
+	0xf4, 0x5d, 0xc7, 0x73, 0xf0, 0x7c, 0xf4, 0xed, 0x86, 0x78, 0xa9, 0x2b, 0x1d, 0xa7, 0xd7, 0x73,
-	0x68, 0xbb, 0x43, 0xba, 0x86, 0x78, 0xd3, 0x3e, 0x41, 0xb0, 0x7c, 0xc7, 0x23, 0x86, 0x4f, 0xee,
+	0x6c, 0x41, 0xac, 0x2b, 0xb4, 0xd3, 0x25, 0x3d, 0x5d, 0xbc, 0xa9, 0x9f, 0x22, 0x38, 0x7b, 0xdb,
-	0xb8, 0xb6, 0x4d, 0xda, 0xbe, 0xe5, 0x3a, 0x3a, 0xf9, 0x5e, 0x9f, 0x50, 0x1f, 0xbf, 0x09, 0x99,
+	0x25, 0xba, 0x47, 0x6e, 0x3b, 0x96, 0x45, 0x3a, 0x9e, 0xe9, 0xd8, 0x1a, 0xf9, 0xde, 0x80, 0x50,
-	0x96, 0x41, 0x49, 0x15, 0xd5, 0xd1, 0x5a, 0x71, 0xe3, 0xd2, 0xcd, 0xc8, 0xda, 0x72, 0xcd, 0x77,
+	0x0f, 0xbf, 0x01, 0xb9, 0xb6, 0x4e, 0x49, 0x0d, 0x35, 0xd0, 0x4a, 0x79, 0xed, 0xc2, 0x8d, 0xd8,
-	0xe8, 0xfe, 0x96, 0x41, 0x89, 0xce, 0x31, 0xf1, 0x32, 0xcc, 0x98, 0xad, 0xa6, 0x63, 0x74, 0x49,
+	0xdc, 0xfe, 0x9c, 0x6f, 0xd3, 0xdd, 0x0d, 0x9d, 0x12, 0x8d, 0x73, 0xe2, 0xb3, 0x30, 0x63, 0xb4,
-	0x35, 0x55, 0x47, 0x6b, 0x05, 0x3d, 0x67, 0xb6, 0x1e, 0x18, 0x5d, 0x82, 0x5f, 0x83, 0xb9, 0x76,
+	0x5b, 0xb6, 0xde, 0x23, 0xb5, 0x4c, 0x03, 0xad, 0x94, 0xb4, 0x82, 0xd1, 0xbe, 0xaf, 0xf7, 0x08,
-	0xb0, 0xbe, 0x40, 0x48, 0x73, 0x84, 0xd9, 0x11, 0x98, 0x23, 0x2e, 0x41, 0x4e, 0xf0, 0x57, 0xcd,
+	0x7e, 0x15, 0xe6, 0x3a, 0xe1, 0xfc, 0x82, 0x21, 0xcb, 0x19, 0x66, 0x47, 0x64, 0xce, 0xb8, 0x04,
-	0xd4, 0xd1, 0x5a, 0x49, 0x97, 0x6f, 0xf8, 0x32, 0x00, 0xed, 0x18, 0x9e, 0x49, 0x9b, 0x4e, 0xbf,
+	0x05, 0x81, 0xaf, 0x96, 0x6b, 0xa0, 0x15, 0x45, 0xf3, 0xdf, 0xf0, 0x45, 0x00, 0xda, 0xd5, 0x5d,
-	0x5b, 0xcd, 0xd6, 0xd1, 0x5a, 0x56, 0x2f, 0x08, 0xc8, 0x83, 0x7e, 0x57, 0xfb, 0x09, 0x82, 0xc5,
+	0x83, 0xb6, 0xec, 0x41, 0xaf, 0x96, 0x6f, 0xa0, 0x95, 0xbc, 0x56, 0x12, 0x94, 0xfb, 0x83, 0x9e,
-	0x6d, 0xcf, 0xed, 0x9d, 0x09, 0x21, 0xb4, 0xdf, 0x23, 0x58, 0xb8, 0x67, 0xd0, 0xb3, 0xa1, 0xd1,
+	0xfa, 0x13, 0x04, 0x8b, 0x9b, 0xae, 0xd3, 0x3f, 0x11, 0x9b, 0x50, 0x7f, 0x87, 0x60, 0xe1, 0xae,
-	0xcb, 0x00, 0xbe, 0xd5, 0x25, 0x4d, 0xea, 0x1b, 0xdd, 0x1e, 0xd7, 0x6a, 0x46, 0x2f, 0x30, 0x48,
+	0x4e, 0x4f, 0x86, 0x44, 0x2f, 0x02, 0x78, 0x66, 0x8f, 0xb4, 0xa8, 0xa7, 0xf7, 0xfa, 0x5c, 0xaa,
-	0x83, 0x01, 0xb4, 0xf7, 0xa1, 0xb4, 0xe5, 0xba, 0xb6, 0x4e, 0x68, 0xcf, 0x75, 0x28, 0xc1, 0x9b,
+	0x39, 0xad, 0xc4, 0x28, 0x4d, 0x46, 0x50, 0xdf, 0x07, 0x65, 0xc3, 0x71, 0x2c, 0x8d, 0xd0, 0xbe,
-	0x90, 0xa3, 0xbe, 0xe1, 0xf7, 0xa9, 0x64, 0xf2, 0xa2, 0x92, 0xc9, 0x06, 0x47, 0xd1, 0x25, 0x2a,
+	0x63, 0x53, 0x82, 0xd7, 0xa1, 0x40, 0x3d, 0xdd, 0x1b, 0x50, 0x1f, 0xe4, 0x79, 0x29, 0xc8, 0x26,
-	0x5e, 0x80, 0xec, 0x81, 0x61, 0xf7, 0x05, 0x8f, 0x79, 0x5d, 0xbc, 0x68, 0x1f, 0xc0, 0x6c, 0xc3,
+	0x67, 0xd1, 0x7c, 0x56, 0xbc, 0x00, 0xf9, 0x3d, 0xdd, 0x1a, 0x08, 0x8c, 0x45, 0x4d, 0xbc, 0xa8,
-	0xf7, 0x2c, 0x67, 0xff, 0x53, 0x5c, 0xbc, 0x30, 0x5c, 0xfc, 0x5f, 0x08, 0x56, 0xb6, 0x09, 0x6d,
+	0x1f, 0xc0, 0x6c, 0xd3, 0x73, 0x4d, 0x7b, 0xf7, 0x33, 0x9c, 0xbc, 0x14, 0x4c, 0xfe, 0x0f, 0x04,
-	0x7b, 0x56, 0xeb, 0x8c, 0xb8, 0xae, 0x06, 0xa5, 0x11, 0x64, 0x77, 0x9b, 0xab, 0x3a, 0xad, 0x47,
+	0xe7, 0x36, 0x09, 0xed, 0xb8, 0x66, 0xfb, 0x84, 0x98, 0xae, 0x0a, 0xca, 0x88, 0xb2, 0xbd, 0xc9,
-	0x60, 0x31, 0x63, 0x64, 0xe3, 0xc6, 0xf8, 0x6d, 0x0a, 0x6a, 0x2a, 0xa1, 0xa6, 0x51, 0xdf, 0xd7,
+	0x45, 0x9d, 0xd5, 0x62, 0xb4, 0x84, 0x32, 0xf2, 0x49, 0x65, 0xfc, 0x26, 0x03, 0x75, 0xd9, 0xa6,
-	0x82, 0x88, 0x4a, 0x71, 0xa2, 0xab, 0x51, 0x22, 0x99, 0x0d, 0x46, 0xbb, 0x35, 0x38, 0x20, 0x08,
+	0xa6, 0x11, 0xdf, 0xd7, 0x42, 0x8f, 0xca, 0xf0, 0x41, 0x57, 0xe2, 0x83, 0xfc, 0x68, 0x30, 0x5a,
-	0xbc, 0xb8, 0x54, 0x69, 0x85, 0x54, 0x1b, 0xb0, 0x78, 0x60, 0x79, 0x7e, 0xdf, 0xb0, 0x9b, 0xed,
+	0xad, 0xc9, 0x09, 0xa1, 0xe3, 0x25, 0x77, 0x95, 0x95, 0xec, 0x6a, 0x0d, 0x16, 0xf7, 0x4c, 0xd7,
-	0x8e, 0xe1, 0x38, 0xc4, 0xe6, 0x7a, 0xa2, 0xd5, 0x4c, 0x3d, 0xbd, 0x56, 0xd0, 0xe7, 0xe5, 0xc7,
+	0x1b, 0xe8, 0x56, 0xab, 0xd3, 0xd5, 0x6d, 0x9b, 0x58, 0x5c, 0x4e, 0xb4, 0x96, 0x6b, 0x64, 0x57,
-	0x3b, 0xe2, 0x1b, 0x53, 0x16, 0xc5, 0xb7, 0x60, 0xa9, 0xd7, 0x19, 0x50, 0xab, 0x7d, 0x84, 0x28,
+	0x4a, 0xda, 0xbc, 0xff, 0xf1, 0xb6, 0xf8, 0xc6, 0x84, 0x45, 0xf1, 0x4d, 0x58, 0xea, 0x77, 0x87,
-	0xcb, 0x89, 0x16, 0x86, 0x5f, 0xc3, 0x54, 0x3c, 0xce, 0xdf, 0x76, 0x0d, 0xf3, 0x6c, 0xc4, 0xf9,
+	0xd4, 0xec, 0x1c, 0x18, 0x94, 0xe7, 0x83, 0x16, 0x82, 0xaf, 0xd1, 0x51, 0xdc, 0xcf, 0xdf, 0x72,
-	0x73, 0x04, 0x55, 0x9d, 0xd8, 0xc4, 0xa0, 0x67, 0xc3, 0x05, 0xb5, 0x5f, 0x22, 0x78, 0x75, 0x87,
+	0x74, 0xe3, 0x64, 0xf8, 0xf9, 0x33, 0x04, 0x35, 0x8d, 0x58, 0x44, 0xa7, 0x27, 0xc3, 0x04, 0xd5,
-	0xf8, 0x21, 0x63, 0xfa, 0x86, 0x6f, 0x51, 0xdf, 0x6a, 0xd3, 0xd3, 0x64, 0xeb, 0x23, 0x04, 0x57,
+	0x5f, 0x20, 0xb8, 0xb4, 0x45, 0xbc, 0x88, 0x32, 0x3d, 0xdd, 0x33, 0xa9, 0x67, 0x76, 0xe8, 0x71,
-	0x12, 0xd9, 0x9a, 0xc6, 0xb7, 0xdf, 0x82, 0x2c, 0x7b, 0xa2, 0xd5, 0x54, 0x3d, 0xbd, 0x56, 0xdc,
+	0xc2, 0xfa, 0x08, 0xc1, 0xe5, 0x54, 0x58, 0xd3, 0xd8, 0xf6, 0x9b, 0x90, 0x67, 0x4f, 0xb4, 0x96,
-	0x58, 0x55, 0xd2, 0xdc, 0x27, 0x83, 0xf7, 0x58, 0xca, 0xd8, 0x33, 0x2c, 0x4f, 0x17, 0xf8, 0xda,
+	0x69, 0x64, 0x57, 0xca, 0x6b, 0xcb, 0xd2, 0x31, 0xf7, 0xc8, 0xf0, 0x5d, 0x16, 0x32, 0x76, 0x74,
-	0x0f, 0x10, 0x2c, 0x35, 0x3a, 0xee, 0xe1, 0x88, 0xa5, 0x97, 0xa1, 0xa0, 0x68, 0xb4, 0xa7, 0xe3,
+	0xd3, 0xd5, 0x04, 0xbf, 0xfa, 0x03, 0x04, 0x4b, 0xcd, 0xae, 0xb3, 0x3f, 0x82, 0xf4, 0x22, 0x04,
-	0xd1, 0x3e, 0x80, 0xe5, 0x23, 0x3c, 0x4c, 0xa3, 0x8d, 0x6b, 0x50, 0x89, 0xd9, 0x43, 0x28, 0xa6,
+	0x14, 0xf7, 0xf6, 0x6c, 0xd2, 0xdb, 0x87, 0x70, 0xf6, 0x00, 0x86, 0x69, 0xa4, 0x71, 0x15, 0xaa,
-	0xa0, 0xcf, 0x45, 0x0d, 0x42, 0xb5, 0x3f, 0x23, 0x58, 0x12, 0xc7, 0xfe, 0x9e, 0xe1, 0xf9, 0xd6,
+	0x09, 0x7d, 0x08, 0xc1, 0x94, 0xb4, 0xb9, 0xb8, 0x42, 0xa8, 0xfa, 0x09, 0x82, 0x25, 0x71, 0xec,
-	0x69, 0xa7, 0xce, 0xab, 0x30, 0xdb, 0x1b, 0xf2, 0x21, 0xf0, 0x32, 0x1c, 0xaf, 0x1c, 0x40, 0xb9,
+	0xef, 0xe8, 0xae, 0x67, 0x1e, 0x77, 0xe8, 0xbc, 0x02, 0xb3, 0xfd, 0x00, 0x87, 0xe0, 0xcb, 0x71,
-	0x1f, 0xfd, 0x09, 0xc1, 0x02, 0x3b, 0xe5, 0xcf, 0x13, 0xcf, 0x7f, 0x44, 0x30, 0x7f, 0xcf, 0xa0,
+	0xbe, 0x4a, 0x48, 0xe5, 0x76, 0xf4, 0x47, 0x04, 0x0b, 0xec, 0x94, 0x3f, 0x4d, 0x98, 0xff, 0x80,
-	0xe7, 0x89, 0xe5, 0xbf, 0xc8, 0x24, 0x1b, 0xf0, 0x7c, 0x9a, 0xc9, 0x83, 0x21, 0x46, 0x99, 0x1e,
+	0x60, 0xfe, 0xae, 0x4e, 0x4f, 0x13, 0xe4, 0x3f, 0xf9, 0x41, 0x36, 0xc4, 0x7c, 0x9c, 0xc1, 0x83,
-	0x1e, 0x2b, 0xb3, 0x11, 0xae, 0xa9, 0xf6, 0xd7, 0x51, 0x36, 0x3e, 0x67, 0x9c, 0xff, 0x0d, 0xc1,
+	0x31, 0xc6, 0x41, 0x07, 0xc7, 0xca, 0x6c, 0x0c, 0x35, 0x55, 0xff, 0x3c, 0x8a, 0xc6, 0xa7, 0x0c,
-	0xe5, 0x1d, 0xe2, 0x07, 0x5c, 0x9f, 0x89, 0xac, 0x3d, 0xa9, 0xb7, 0x3c, 0x17, 0x67, 0x8e, 0x92,
+	0xf9, 0x5f, 0x10, 0x5c, 0xdc, 0x22, 0x5e, 0x88, 0xfa, 0x44, 0x44, 0xed, 0x49, 0xad, 0xe5, 0x99,
-	0xf9, 0x53, 0xc9, 0xed, 0x7f, 0x40, 0xb0, 0xc8, 0xf2, 0xea, 0xd9, 0x70, 0x82, 0x09, 0xaa, 0x42,
+	0x38, 0x73, 0xa4, 0xe0, 0x8f, 0x25, 0xb6, 0xff, 0x1e, 0xc1, 0x22, 0x8b, 0xab, 0x27, 0xc3, 0x08,
-	0xed, 0x37, 0xf2, 0x34, 0x0a, 0x73, 0x3c, 0x8d, 0xea, 0x14, 0x8e, 0x97, 0x52, 0x39, 0x1e, 0x63,
+	0x26, 0xc8, 0x0a, 0xd5, 0x5f, 0xfb, 0xa7, 0x51, 0x14, 0xf1, 0x34, 0xa2, 0x93, 0x18, 0x5e, 0x46,
-	0x2e, 0x80, 0xec, 0x6e, 0xd3, 0x6a, 0xba, 0x9e, 0x66, 0xcc, 0x85, 0x61, 0xda, 0x4f, 0x11, 0x2c,
+	0x66, 0x78, 0x0c, 0x5c, 0x48, 0xd9, 0xde, 0xa4, 0xb5, 0x6c, 0x23, 0xcb, 0xc0, 0x45, 0x69, 0xea,
-	0x0d, 0x6b, 0xd2, 0x06, 0xd9, 0xef, 0x12, 0xc7, 0x7f, 0x71, 0x7d, 0xc6, 0xb5, 0x91, 0x52, 0x54,
+	0x4f, 0x11, 0x2c, 0x05, 0x39, 0x69, 0x93, 0xec, 0xf6, 0x88, 0xed, 0x3d, 0xbf, 0x3c, 0x93, 0xd2,
-	0x93, 0x97, 0xa0, 0x40, 0xc5, 0x3e, 0x41, 0xb9, 0x39, 0x02, 0x68, 0x1f, 0x23, 0x58, 0x3e, 0xc2,
+	0xc8, 0x48, 0xb2, 0xc9, 0x0b, 0x50, 0xa2, 0x62, 0x9d, 0x30, 0xdd, 0x1c, 0x11, 0xd4, 0x8f, 0x11,
-	0xce, 0x34, 0xca, 0xaa, 0xc2, 0x8c, 0xe5, 0x98, 0xe4, 0x69, 0xc0, 0xcd, 0xf0, 0x95, 0x7d, 0x69,
+	0x9c, 0x3d, 0x00, 0x67, 0x1a, 0x61, 0xd5, 0x60, 0xc6, 0xb4, 0x0d, 0xf2, 0x24, 0x44, 0x13, 0xbc,
-	0xf5, 0x2d, 0xdb, 0x0c, 0xd8, 0x18, 0xbe, 0xe2, 0x55, 0x28, 0x11, 0xc7, 0x68, 0xd9, 0xa4, 0xc9,
+	0xb2, 0x2f, 0xed, 0x81, 0x69, 0x19, 0x21, 0x8c, 0xe0, 0x15, 0x2f, 0x83, 0x42, 0x6c, 0xbd, 0x6d,
-	0x71, 0xb9, 0x51, 0xf3, 0x7a, 0x51, 0xc0, 0x76, 0x19, 0x48, 0xfb, 0x19, 0x82, 0x79, 0x66, 0x53,
+	0x91, 0x16, 0xe7, 0xe5, 0x4a, 0x2d, 0x6a, 0x65, 0x41, 0xdb, 0x66, 0x24, 0xf5, 0x67, 0x08, 0xe6,
-	0xc9, 0x23, 0x7d, 0xb9, 0x3a, 0xab, 0x43, 0x31, 0x64, 0x34, 0xc9, 0x6e, 0x18, 0xa4, 0x3d, 0x81,
+	0x99, 0x4e, 0x7d, 0x8c, 0xf4, 0xc5, 0xca, 0xac, 0x01, 0xe5, 0x88, 0xd2, 0x7c, 0xb8, 0x51, 0x92,
-	0x85, 0x28, 0x3b, 0xd3, 0xe8, 0xec, 0x55, 0x80, 0xc0, 0x22, 0xc2, 0xb7, 0xd2, 0x7a, 0x08, 0xa2,
+	0xfa, 0x18, 0x16, 0xe2, 0x70, 0xa6, 0x91, 0xd9, 0x25, 0x80, 0x50, 0x23, 0xc2, 0xb6, 0xb2, 0x5a,
-	0xfd, 0x17, 0x01, 0x16, 0xe5, 0x05, 0x57, 0xc6, 0x29, 0x5f, 0x7f, 0x1f, 0x5b, 0xc4, 0x36, 0xc3,
+	0x84, 0xa2, 0xfe, 0x07, 0x01, 0x16, 0xe9, 0x05, 0x17, 0xc6, 0x31, 0x97, 0xbf, 0x8f, 0x4c, 0x62,
-	0x19, 0xac, 0xc0, 0x21, 0xfc, 0xf3, 0x36, 0x94, 0xc8, 0x53, 0xdf, 0x33, 0x9a, 0x3d, 0xc3, 0x33,
+	0x19, 0xd1, 0x08, 0x56, 0xe2, 0x14, 0xfe, 0x79, 0x13, 0x14, 0xf2, 0xc4, 0x73, 0xf5, 0x56, 0x5f,
-	0xba, 0xe2, 0xf2, 0x31, 0x51, 0xb2, 0x29, 0x72, 0xb2, 0x3d, 0x4e, 0xa5, 0xfd, 0x9d, 0x15, 0x26,
+	0x77, 0xf5, 0x9e, 0x28, 0x3e, 0x26, 0x0a, 0x36, 0x65, 0x3e, 0x6c, 0x87, 0x8f, 0x52, 0xff, 0xca,
-	0xd2, 0x29, 0xcf, 0xba, 0xc4, 0x97, 0x01, 0xb8, 0xd3, 0x8a, 0xcf, 0x59, 0xf1, 0x99, 0x43, 0x78,
+	0x12, 0x13, 0xdf, 0x28, 0x4f, 0xfa, 0x8e, 0x2f, 0x02, 0x70, 0xa3, 0x15, 0x9f, 0xf3, 0xe2, 0x33,
-	0x3a, 0xff, 0x18, 0x41, 0x85, 0x8b, 0x20, 0xe4, 0xe9, 0xb1, 0x65, 0x63, 0x34, 0x28, 0x46, 0x33,
+	0xa7, 0xf0, 0x70, 0xfe, 0x31, 0x82, 0x2a, 0xdf, 0x82, 0xd8, 0x4f, 0x9f, 0x4d, 0x9b, 0x18, 0x83,
-	0x26, 0x84, 0xbe, 0x02, 0x39, 0xa9, 0xd8, 0xf4, 0xa4, 0x8a, 0x95, 0x04, 0xc7, 0x88, 0xa1, 0xfd,
+	0x12, 0x63, 0xc6, 0xb8, 0xd0, 0x57, 0xa0, 0xe0, 0x0b, 0x36, 0x3b, 0xa9, 0x60, 0xfd, 0x01, 0x87,
-	0x0e, 0xc1, 0x62, 0x4c, 0xe5, 0xd3, 0x78, 0xf4, 0x43, 0xc0, 0x42, 0x42, 0x73, 0x24, 0xf6, 0xf0,
+	0x6c, 0x43, 0xfd, 0x2d, 0x82, 0xc5, 0x84, 0xc8, 0xa7, 0xb1, 0xe8, 0x07, 0x80, 0xc5, 0x0e, 0x8d,
-	0xe8, 0x89, 0xdd, 0x98, 0xe5, 0x4b, 0x5c, 0x49, 0xfa, 0x2b, 0x56, 0x0c, 0x42, 0xb5, 0x7f, 0x22,
+	0xd1, 0xb6, 0x83, 0xa3, 0x27, 0x51, 0x31, 0xfb, 0x2f, 0x49, 0x21, 0x69, 0x2f, 0x99, 0x09, 0x0a,
-	0xb8, 0xb4, 0x43, 0x7c, 0x8e, 0xba, 0xc5, 0x72, 0xc7, 0x9e, 0xe7, 0xee, 0x7b, 0x84, 0xd2, 0xf3,
+	0x55, 0xff, 0x8e, 0xe0, 0xc2, 0x16, 0xf1, 0x38, 0xeb, 0x06, 0x8b, 0x1d, 0x3b, 0xae, 0xb3, 0xeb,
-	0xeb, 0x1f, 0xbf, 0x12, 0xb5, 0x8a, 0x4a, 0xa4, 0x69, 0xf4, 0xbf, 0x0a, 0x25, 0xbe, 0x07, 0x31,
+	0x12, 0x4a, 0x4f, 0xaf, 0x7d, 0xfc, 0x52, 0xe4, 0x2a, 0xb2, 0x2d, 0x4d, 0x23, 0xff, 0x65, 0x50,
-	0x9b, 0x9e, 0x7b, 0x48, 0xa5, 0x1f, 0x15, 0x25, 0x4c, 0x77, 0x0f, 0xb9, 0x43, 0xf8, 0xae, 0x6f,
+	0xf8, 0x1a, 0xc4, 0x68, 0xb9, 0xce, 0x3e, 0xf5, 0xed, 0xa8, 0xec, 0xd3, 0x34, 0x67, 0x9f, 0x1b,
-	0xd8, 0x02, 0x41, 0x1e, 0x0c, 0x1c, 0xc2, 0x3e, 0xf3, 0x18, 0x1c, 0x32, 0xc6, 0x16, 0x27, 0xe7,
+	0x84, 0xe7, 0x78, 0xba, 0x25, 0x18, 0xfc, 0x83, 0x81, 0x53, 0xd8, 0x67, 0xee, 0x83, 0x01, 0x30,
-	0x57, 0xc7, 0x1f, 0x22, 0x58, 0x8c, 0x89, 0x32, 0x8d, 0x6e, 0x6f, 0x8b, 0x4a, 0x4a, 0x08, 0x33,
+	0x36, 0x39, 0x39, 0xbd, 0x32, 0xfe, 0x10, 0xc1, 0x62, 0x62, 0x2b, 0xd3, 0xc8, 0xf6, 0x96, 0xc8,
-	0xbb, 0x71, 0x45, 0x49, 0x13, 0xda, 0x4c, 0x60, 0x6b, 0x9f, 0x20, 0xa8, 0xb0, 0xdb, 0xd6, 0x39,
+	0xa4, 0xc4, 0x66, 0x66, 0xd7, 0x2e, 0x4b, 0xc7, 0x44, 0x16, 0x13, 0xdc, 0xea, 0xa7, 0x08, 0xaa,
-	0x4f, 0x68, 0xff, 0x43, 0x50, 0xde, 0x75, 0x28, 0xf1, 0xfc, 0xb3, 0x5f, 0x4c, 0xe3, 0x5b, 0x90,
+	0xac, 0xda, 0x3a, 0xe5, 0x01, 0xed, 0xbf, 0x08, 0x2a, 0xdb, 0x36, 0x25, 0xae, 0x77, 0xf2, 0x93,
-	0xf7, 0xdc, 0xc3, 0xa6, 0x69, 0xf8, 0x86, 0x3c, 0x8a, 0x56, 0x94, 0xec, 0x6d, 0xd9, 0x6e, 0x4b,
+	0x69, 0x7c, 0x13, 0x8a, 0xae, 0xb3, 0xdf, 0x32, 0x74, 0x4f, 0xf7, 0x8f, 0xa2, 0x73, 0x52, 0x78,
-	0x9f, 0xf1, 0xdc, 0xc3, 0x6d, 0xc3, 0x37, 0xf0, 0x45, 0x28, 0x74, 0x0c, 0xda, 0x69, 0x3e, 0x21,
+	0x1b, 0x96, 0xd3, 0xd6, 0x66, 0x5c, 0x67, 0x7f, 0x53, 0xf7, 0x74, 0x7c, 0x1e, 0x4a, 0x5d, 0x9d,
-	0x03, 0x5a, 0xcd, 0xd5, 0xd3, 0x6b, 0x65, 0x3d, 0xcf, 0x00, 0xf7, 0xc9, 0x80, 0x32, 0x67, 0x9a,
+	0x76, 0x5b, 0x8f, 0xc9, 0x90, 0xd6, 0x0a, 0x8d, 0xec, 0x4a, 0x45, 0x2b, 0x32, 0xc2, 0x3d, 0x32,
-	0x1d, 0xca, 0x3f, 0x8d, 0x17, 0x5d, 0x81, 0xa2, 0xe7, 0x1e, 0xee, 0x6e, 0x37, 0x5b, 0x64, 0xdf,
+	0xa4, 0xcc, 0x98, 0x66, 0x83, 0xfd, 0x4f, 0x63, 0x45, 0x97, 0xa1, 0xec, 0x3a, 0xfb, 0xdb, 0x9b,
-	0x72, 0x64, 0x80, 0x02, 0x07, 0x6d, 0x31, 0x08, 0xe3, 0x42, 0x20, 0x10, 0xc7, 0x94, 0xe1, 0x99,
+	0xad, 0x36, 0xd9, 0x35, 0x6d, 0xdf, 0x41, 0x81, 0x93, 0x36, 0x18, 0x85, 0xa1, 0x10, 0x0c, 0xc4,
-	0xe7, 0x80, 0x6f, 0x39, 0xa6, 0x76, 0x00, 0x95, 0x3d, 0xdb, 0x68, 0x93, 0x8e, 0x6b, 0x9b, 0xc4,
+	0x36, 0x7c, 0xf7, 0x2c, 0x72, 0xc2, 0xb7, 0x6d, 0x43, 0xdd, 0x83, 0xea, 0x8e, 0xa5, 0x77, 0x48,
-	0xe3, 0xd9, 0x1e, 0x57, 0x20, 0xed, 0x1b, 0xfb, 0xf2, 0x38, 0x61, 0x8f, 0xf8, 0xcb, 0x90, 0xf1,
+	0xd7, 0xb1, 0x0c, 0xe2, 0xf2, 0x68, 0x8f, 0xab, 0x90, 0xf5, 0xf4, 0x5d, 0xff, 0x38, 0x61, 0x8f,
-	0x07, 0xbd, 0xa1, 0xa3, 0x7e, 0x5e, 0x99, 0x77, 0x43, 0xcb, 0x3c, 0x1c, 0xf4, 0x88, 0xce, 0x29,
+	0xf8, 0xcb, 0x90, 0xf3, 0x86, 0xfd, 0xc0, 0x50, 0x5f, 0x91, 0xc6, 0xdd, 0xc8, 0x34, 0x0f, 0x86,
-	0xf0, 0x12, 0xe4, 0x78, 0x5f, 0x58, 0x1c, 0x34, 0x25, 0x5d, 0xbe, 0x69, 0x8f, 0x22, 0xfb, 0xee,
+	0x7d, 0xa2, 0xf1, 0x11, 0x78, 0x09, 0x0a, 0xfc, 0x5e, 0x58, 0x1c, 0x34, 0x8a, 0xe6, 0xbf, 0xa9,
-	0x78, 0x6e, 0xbf, 0x87, 0x77, 0xa1, 0xd4, 0x1b, 0xc1, 0x98, 0x12, 0x92, 0xb3, 0x7c, 0x9c, 0x69,
+	0x0f, 0x63, 0xeb, 0x6e, 0xb9, 0xce, 0xa0, 0x8f, 0xb7, 0x41, 0xe9, 0x8f, 0x68, 0x4c, 0x08, 0xe9,
-	0x3d, 0x42, 0xaa, 0xfd, 0x27, 0x05, 0xe5, 0x06, 0x31, 0xbc, 0x76, 0xe7, 0x3c, 0x5c, 0x34, 0x99,
+	0x51, 0x3e, 0x09, 0x5a, 0x8b, 0x0d, 0x55, 0xff, 0x9d, 0x81, 0x4a, 0x93, 0xe8, 0x6e, 0xa7, 0x7b,
-	0xc6, 0x4d, 0x6a, 0xcb, 0x18, 0x61, 0x8f, 0xf8, 0x06, 0xbc, 0x12, 0x12, 0xa8, 0xb9, 0xcf, 0x14,
+	0x1a, 0x0a, 0x4d, 0x26, 0x71, 0x83, 0x5a, 0xbe, 0x8f, 0xb0, 0x47, 0x7c, 0x1d, 0x5e, 0x8a, 0x6c,
-	0x54, 0xcd, 0xf1, 0xd1, 0x4b, 0xa5, 0x17, 0x57, 0xdc, 0x5b, 0x90, 0x37, 0xa9, 0xdd, 0xe4, 0x26,
+	0xa8, 0xb5, 0xcb, 0x04, 0x54, 0x2b, 0xf0, 0xd6, 0x4b, 0xb5, 0x9f, 0x14, 0xdc, 0x9b, 0x50, 0x34,
-	0x9a, 0xe1, 0x26, 0x52, 0xcb, 0xb7, 0x4d, 0x6d, 0x6e, 0x9a, 0x19, 0x53, 0x3c, 0xe0, 0xbb, 0x50,
+	0xa8, 0xd5, 0xe2, 0x2a, 0x9a, 0xe1, 0x2a, 0x92, 0xef, 0x6f, 0x93, 0x5a, 0x5c, 0x35, 0x33, 0x86,
-	0xa6, 0x5c, 0x4b, 0xc3, 0x32, 0x2b, 0x3f, 0x69, 0x35, 0x50, 0x12, 0x74, 0xb2, 0xce, 0xba, 0x0f,
+	0x78, 0xc0, 0x77, 0xa0, 0x42, 0xb9, 0x94, 0x82, 0x34, 0xab, 0x38, 0x69, 0x36, 0xa0, 0x88, 0x71,
-	0x99, 0x7b, 0x96, 0xcf, 0xe5, 0x60, 0x85, 0x27, 0xe2, 0x85, 0x27, 0x7b, 0xc4, 0x2b, 0xa1, 0xc0,
+	0x7e, 0x9e, 0xf5, 0x3f, 0x04, 0x73, 0x1a, 0xf1, 0x5c, 0x93, 0xec, 0x91, 0x53, 0x21, 0xf0, 0x6b,
-	0x49, 0x71, 0x0f, 0x08, 0xa2, 0x83, 0x8f, 0x94, 0x5c, 0x4f, 0xba, 0x46, 0x4a, 0x97, 0x6f, 0xda,
+	0x90, 0x35, 0x0d, 0xca, 0x05, 0x5e, 0x5e, 0xab, 0x49, 0x6f, 0xde, 0xb7, 0x37, 0xa9, 0xc6, 0x98,
-	0x77, 0x46, 0xa6, 0xa3, 0x7d, 0xdb, 0xa7, 0x2f, 0x16, 0x16, 0x18, 0x32, 0x1d, 0x4b, 0xde, 0x52,
+	0xf0, 0xcb, 0x50, 0x71, 0x06, 0x5e, 0x7f, 0xe0, 0xb5, 0x78, 0x6c, 0x13, 0x9e, 0x5c, 0xd2, 0x14,
-	0x4b, 0x3a, 0x7f, 0xd6, 0x7e, 0x88, 0xa0, 0x74, 0xd7, 0xee, 0xd3, 0x97, 0xe1, 0x14, 0xaa, 0x26,
+	0x41, 0xbc, 0xc3, 0x69, 0xea, 0x27, 0x31, 0x09, 0xd0, 0x81, 0xe5, 0xd1, 0xe7, 0x73, 0x67, 0x1f,
-	0x5f, 0x5a, 0xdd, 0xe4, 0xfb, 0x47, 0x0a, 0x16, 0xf7, 0x88, 0x47, 0x2d, 0xea, 0x13, 0xc7, 0x97,
+	0x59, 0x66, 0x12, 0x64, 0xdf, 0x80, 0xb2, 0x80, 0x24, 0x02, 0x93, 0x48, 0xe5, 0x2e, 0x49, 0xc7,
-	0x95, 0xff, 0xae, 0xf3, 0xd8, 0x8d, 0x5e, 0xb1, 0x50, 0xec, 0x8a, 0xf5, 0xe9, 0x5c, 0x38, 0x58,
+	0x70, 0x98, 0x2c, 0x28, 0x69, 0x22, 0x66, 0x53, 0xf6, 0xac, 0xde, 0x83, 0xdc, 0x5d, 0xd3, 0xe3,
-	0x3a, 0x70, 0x7b, 0xc4, 0x69, 0xfa, 0x96, 0x4c, 0x76, 0x19, 0x3d, 0xcf, 0x00, 0x0f, 0xad, 0x2e,
+	0xf6, 0xc7, 0x0a, 0x06, 0xc4, 0x0b, 0x06, 0xf6, 0x88, 0xcf, 0x45, 0x02, 0x5e, 0x86, 0x7b, 0x6e,
-	0x61, 0xc9, 0x84, 0x12, 0xc3, 0x26, 0xa6, 0xf8, 0x2c, 0x06, 0x21, 0x20, 0x40, 0x1c, 0x61, 0x15,
+	0x18, 0xd5, 0x78, 0x2b, 0xd0, 0x71, 0x7d, 0x97, 0xce, 0x68, 0xfe, 0x9b, 0xfa, 0xde, 0xc8, 0xe5,
-	0x4a, 0x8f, 0x99, 0x06, 0x87, 0x18, 0x39, 0x8e, 0x51, 0x94, 0x30, 0x8e, 0xb2, 0x02, 0x79, 0xa7,
+	0xa6, 0xd8, 0x3f, 0x86, 0x5c, 0xd7, 0xf4, 0x6f, 0x17, 0x14, 0x8d, 0x3f, 0xab, 0x3f, 0x44, 0xa0,
-	0xdf, 0x15, 0xd5, 0xc0, 0x8c, 0x28, 0x3b, 0x9d, 0x7e, 0x97, 0x97, 0x0a, 0x2b, 0x90, 0xef, 0x92,
+	0xdc, 0xb1, 0x06, 0xf4, 0x45, 0x38, 0xb3, 0xec, 0x72, 0x36, 0x2b, 0xbf, 0x9c, 0xfd, 0x5b, 0x06,
-	0x6e, 0x93, 0x5a, 0xcf, 0x48, 0x35, 0x2f, 0x3e, 0x75, 0x49, 0xb7, 0x61, 0x3d, 0x23, 0xc3, 0xb6,
+	0x16, 0x77, 0x88, 0x4b, 0x4d, 0xea, 0x11, 0xdb, 0xf3, 0x2b, 0xb6, 0x6d, 0xfb, 0x91, 0x13, 0x2f,
-	0x02, 0xa9, 0x16, 0xb8, 0x03, 0xab, 0x5d, 0x50, 0xea, 0x2a, 0x72, 0x1c, 0xfe, 0x42, 0x34, 0xb1,
+	0x8d, 0x51, 0xa2, 0x34, 0xfe, 0x6c, 0x0a, 0x45, 0x16, 0xc6, 0x9d, 0x3e, 0xb1, 0x5b, 0x9e, 0xe9,
-	0x95, 0x0a, 0x7d, 0x71, 0x3b, 0x2f, 0x81, 0x34, 0x6c, 0xcc, 0xcc, 0x5f, 0x80, 0x58, 0x90, 0x27,
+	0x1f, 0x52, 0x39, 0xad, 0xc8, 0x08, 0x0f, 0xcc, 0x1e, 0x61, 0x87, 0x00, 0x25, 0xba, 0x45, 0x0c,
-	0xb4, 0xd6, 0x7f, 0x8d, 0xa0, 0x9e, 0xcc, 0xd5, 0x34, 0xf9, 0xfe, 0x1b, 0x90, 0xb5, 0x9c, 0xc7,
+	0xf1, 0x59, 0x34, 0xb0, 0x40, 0x90, 0x38, 0xc3, 0x32, 0x28, 0x8f, 0x98, 0x04, 0x03, 0x8e, 0x02,
-	0xee, 0xb0, 0x08, 0xbe, 0xae, 0x4e, 0x8f, 0xca, 0x7d, 0x05, 0xa1, 0xf6, 0x6f, 0x04, 0x95, 0x77,
+	0xe7, 0x28, 0xfb, 0x34, 0xce, 0x72, 0x0e, 0x8a, 0xf6, 0xa0, 0x27, 0xb2, 0xb8, 0x19, 0x51, 0x2e,
-	0xfb, 0xc4, 0x1b, 0x7c, 0xd6, 0xae, 0x17, 0x36, 0x7f, 0x26, 0x6a, 0xfe, 0xb0, 0xd3, 0x64, 0xa3,
+	0xd8, 0x83, 0x1e, 0x4f, 0xf1, 0xce, 0x41, 0xb1, 0x47, 0x7a, 0x2d, 0x6a, 0x3e, 0x25, 0xb5, 0xa2,
-	0x4e, 0x13, 0xad, 0x23, 0x72, 0x63, 0x2e, 0x39, 0x33, 0x91, 0x4b, 0x8e, 0xf6, 0x1c, 0x41, 0x6d,
+	0xf8, 0xd4, 0x23, 0xbd, 0xa6, 0xf9, 0x94, 0x04, 0xd7, 0x41, 0xa4, 0x56, 0xe2, 0x81, 0x47, 0x1e,
-	0x87, 0xf8, 0x71, 0x51, 0x4f, 0xcf, 0x29, 0x3e, 0x42, 0x70, 0x51, 0xc9, 0xd0, 0x34, 0xfe, 0xf0,
+	0x3a, 0x7c, 0x59, 0xc5, 0xd2, 0x98, 0x9f, 0x8b, 0xe6, 0x83, 0x54, 0xa0, 0xcf, 0xaf, 0xe7, 0x25,
-	0xd5, 0xa8, 0x3f, 0xa8, 0x8f, 0xcb, 0x23, 0x5b, 0x4a, 0x57, 0x58, 0x84, 0x79, 0x9d, 0xec, 0x33,
+	0xf0, 0x15, 0x9b, 0x50, 0xf3, 0x17, 0x20, 0x11, 0x2b, 0x52, 0x5a, 0x22, 0xbf, 0x42, 0xd0, 0x48,
-	0x4f, 0xf1, 0xde, 0xb6, 0x9c, 0x27, 0x52, 0x35, 0xac, 0x36, 0x59, 0x88, 0xc2, 0x25, 0x87, 0x5f,
+	0x47, 0x35, 0xcd, 0x39, 0xfd, 0x4d, 0xc8, 0x9b, 0xf6, 0x23, 0x27, 0x28, 0x5e, 0xae, 0xc9, 0x8f,
-	0x82, 0x19, 0xc3, 0x34, 0xd9, 0xb5, 0x62, 0xac, 0xda, 0xbe, 0x29, 0x70, 0xf4, 0x21, 0x72, 0x48,
+	0x35, 0xe9, 0xba, 0x62, 0xa0, 0xfa, 0x4f, 0x04, 0xd5, 0x77, 0x06, 0xc4, 0x1d, 0x7e, 0xde, 0xa6,
-	0xb2, 0xd4, 0xc4, 0x92, 0x5d, 0xff, 0x3a, 0xcc, 0xc5, 0x8a, 0x0a, 0x9c, 0x87, 0xcc, 0x03, 0xd7,
+	0x17, 0x55, 0x7f, 0x2e, 0xae, 0xfe, 0xa8, 0xd1, 0xe4, 0xe3, 0x46, 0x13, 0xcf, 0xff, 0x0a, 0x63,
-	0x21, 0x95, 0x0b, 0xb8, 0x02, 0xa5, 0x2d, 0xcb, 0x31, 0xbc, 0xc1, 0x7b, 0xa4, 0xed, 0xbb, 0x5e,
+	0x8a, 0xd3, 0x99, 0x58, 0x71, 0xaa, 0x3e, 0x43, 0x50, 0xdf, 0x22, 0x5e, 0x72, 0xab, 0xc7, 0x67,
-	0xc5, 0xc4, 0x73, 0x50, 0xbc, 0x6b, 0xbb, 0x86, 0x2f, 0x01, 0x64, 0xe3, 0xe7, 0x8b, 0x50, 0x7e,
+	0x14, 0x1f, 0x21, 0x38, 0x2f, 0x05, 0x34, 0x8d, 0x3d, 0x7c, 0x35, 0x6e, 0x0f, 0xf2, 0x34, 0xe7,
-	0x87, 0x6f, 0xd3, 0x20, 0xde, 0x81, 0xd5, 0x26, 0xb8, 0x09, 0x95, 0xf8, 0x4f, 0x15, 0xf8, 0x75,
+	0xc0, 0x92, 0xbe, 0x29, 0x2c, 0xc2, 0xbc, 0x46, 0x76, 0x99, 0xa5, 0xb8, 0x6f, 0x99, 0xf6, 0x63,
-	0xa5, 0xc2, 0x12, 0xfe, 0xbd, 0xa8, 0x8d, 0x63, 0x5c, 0xbb, 0x80, 0x3f, 0x80, 0xd9, 0xe8, 0xef,
+	0x5f, 0x34, 0x2c, 0xa7, 0x5c, 0x88, 0xd3, 0x7d, 0x84, 0x5f, 0x82, 0x19, 0xdd, 0x30, 0x58, 0x39,
-	0x0e, 0x58, 0x1d, 0x9f, 0xca, 0x7f, 0x22, 0x8e, 0x5b, 0xbc, 0x09, 0xe5, 0xc8, 0xdf, 0x0b, 0xf8,
+	0x38, 0x56, 0x6c, 0xdf, 0x12, 0x3c, 0x5a, 0xc0, 0x1c, 0xd9, 0x59, 0x66, 0xe2, 0x9d, 0x5d, 0xfb,
-	0x9a, 0x72, 0x6d, 0xd5, 0x1f, 0x0e, 0xb5, 0x55, 0x25, 0x6a, 0xf8, 0x0f, 0x03, 0xc1, 0x7d, 0x74,
+	0x3a, 0xcc, 0x25, 0x92, 0x41, 0x5c, 0x84, 0xdc, 0x7d, 0xc7, 0x26, 0xd5, 0x33, 0xb8, 0x0a, 0xca,
-	0x88, 0x9b, 0xc0, 0xbd, 0x72, 0xd2, 0x7b, 0x1c, 0xf7, 0x06, 0xbc, 0x72, 0x64, 0x26, 0x8b, 0xdf,
+	0x86, 0x69, 0xeb, 0xee, 0xf0, 0x5d, 0xd2, 0xf1, 0x1c, 0xb7, 0x6a, 0xe0, 0x39, 0x28, 0xdf, 0xb1,
-	0x50, 0xae, 0x9f, 0x34, 0xbb, 0x3d, 0x6e, 0x8b, 0x43, 0xc0, 0x47, 0xa7, 0xf4, 0xf8, 0xa6, 0xda,
+	0x1c, 0xdd, 0xf3, 0x09, 0x64, 0xed, 0x5f, 0x8b, 0x50, 0x79, 0x9b, 0x2f, 0xd3, 0x24, 0xee, 0x9e,
-	0x02, 0x49, 0xff, 0x28, 0xd4, 0xd6, 0x27, 0xc6, 0x0f, 0x14, 0xf7, 0x23, 0x04, 0xcb, 0x09, 0x83,
+	0xd9, 0x21, 0xb8, 0x05, 0xd5, 0xe4, 0xcf, 0x30, 0xf8, 0x35, 0xa9, 0xc0, 0x52, 0xfe, 0x99, 0xa9,
-	0x54, 0xbc, 0xa9, 0x5c, 0x6e, 0xfc, 0x34, 0xb8, 0x76, 0xeb, 0x64, 0x44, 0x01, 0x23, 0x0e, 0xcc,
+	0x8f, 0x03, 0xae, 0x9e, 0xc1, 0x1f, 0xc0, 0x6c, 0xfc, 0x37, 0x15, 0x2c, 0xf7, 0x4f, 0xe9, 0xbf,
-	0xc5, 0x46, 0x97, 0xf8, 0x86, 0x72, 0x29, 0xf5, 0x90, 0xb5, 0xf6, 0xfa, 0x64, 0xc8, 0xc1, 0x7e,
+	0x2c, 0x87, 0x4d, 0xde, 0x82, 0x4a, 0xec, 0xaf, 0x13, 0x7c, 0x55, 0x3a, 0xb7, 0xec, 0xcf, 0x94,
-	0x8f, 0x60, 0x2e, 0x36, 0xae, 0x4c, 0xd8, 0x4f, 0x3d, 0xd4, 0x3c, 0xce, 0xa0, 0xef, 0x43, 0x39,
+	0xfa, 0xb2, 0x94, 0x35, 0xfa, 0x67, 0x88, 0x40, 0x1f, 0x6f, 0xbe, 0xa7, 0xa0, 0x97, 0x76, 0xe8,
-	0x32, 0x57, 0x4c, 0xf0, 0x78, 0xd5, 0xec, 0xf1, 0xb8, 0xa5, 0x1f, 0x41, 0x29, 0x3c, 0xfe, 0xc3,
+	0x0f, 0x43, 0xaf, 0xc3, 0x4b, 0x07, 0x7a, 0xe9, 0xf8, 0x75, 0xe9, 0xfc, 0x69, 0x3d, 0xf7, 0xc3,
-	0x6b, 0x49, 0xb1, 0x74, 0x64, 0xe1, 0x93, 0x84, 0xd2, 0x68, 0x72, 0x30, 0x26, 0x94, 0x8e, 0x0c,
+	0x96, 0xd8, 0x07, 0x7c, 0xf0, 0xef, 0x0a, 0x7c, 0x43, 0xae, 0x81, 0xb4, 0x7f, 0x4b, 0xea, 0xab,
-	0x44, 0x26, 0x0f, 0xa5, 0xd0, 0xfa, 0x63, 0x43, 0xe9, 0xc4, 0x5b, 0x7c, 0x88, 0x60, 0x49, 0x3d,
+	0x13, 0xf3, 0x87, 0x82, 0xfb, 0x11, 0x82, 0xb3, 0x29, 0x0d, 0x70, 0xbc, 0x2e, 0x9d, 0x6e, 0x7c,
-	0x3d, 0xc2, 0x1b, 0x49, 0xbe, 0x99, 0x3c, 0x27, 0xab, 0x6d, 0x9e, 0x88, 0x26, 0xd0, 0xe2, 0x13,
+	0x17, 0xbf, 0x7e, 0xf3, 0x68, 0x83, 0x42, 0x20, 0x36, 0xcc, 0x25, 0x5a, 0xce, 0xf8, 0xba, 0x74,
-	0x98, 0x8d, 0xce, 0x5f, 0x12, 0xb4, 0xa8, 0x1c, 0x2b, 0xd5, 0x6e, 0x4c, 0x84, 0x1b, 0x6c, 0xf6,
+	0x2a, 0x79, 0x73, 0xbc, 0xfe, 0xda, 0x64, 0xcc, 0xe1, 0x7a, 0x0f, 0x61, 0x2e, 0xd1, 0x66, 0x4e,
-	0x6d, 0x28, 0x86, 0x7a, 0xe3, 0xf8, 0xb5, 0x31, 0x7e, 0x1c, 0x6e, 0xbd, 0x1c, 0xa7, 0xc9, 0x0e,
+	0x59, 0x4f, 0xde, 0x8c, 0x3e, 0x4c, 0xa1, 0xef, 0x43, 0x25, 0xd6, 0x0f, 0x4e, 0xb1, 0x78, 0x59,
-	0x94, 0x23, 0xfd, 0xd0, 0x24, 0x1f, 0x56, 0xb4, 0xa9, 0x6b, 0xd7, 0x27, 0x41, 0x0d, 0x04, 0xe8,
+	0xcf, 0xf8, 0xb0, 0xa9, 0x1f, 0x82, 0x12, 0x6d, 0xdb, 0xe2, 0x95, 0x34, 0x5f, 0x3a, 0x30, 0xf1,
-	0x40, 0x39, 0xd2, 0x9d, 0x4a, 0xd8, 0x49, 0xd5, 0x8c, 0x4b, 0xd8, 0x49, 0xd9, 0xec, 0xd2, 0x2e,
+	0x51, 0x5c, 0x69, 0xd4, 0xf1, 0x19, 0xe3, 0x4a, 0x07, 0x1a, 0x59, 0x93, 0xbb, 0x52, 0x64, 0xfe,
-	0xe0, 0xef, 0x87, 0x1a, 0x61, 0x91, 0x66, 0x23, 0xfe, 0xe2, 0xd8, 0x75, 0x54, 0xbd, 0xd6, 0xda,
+	0xb1, 0xae, 0x74, 0xe4, 0x25, 0x3e, 0x44, 0xb0, 0x24, 0xef, 0xfa, 0xe1, 0xb5, 0x34, 0xdb, 0x4c,
-	0xc6, 0x49, 0x48, 0x02, 0x16, 0xde, 0x85, 0x42, 0xd0, 0x04, 0xc3, 0x57, 0x13, 0xd3, 0xc2, 0x49,
+	0xef, 0x6f, 0xd6, 0xd7, 0x8f, 0x34, 0x26, 0x94, 0xe2, 0x63, 0x98, 0x8d, 0xf7, 0xcd, 0x52, 0xa4,
-	0x2c, 0xd5, 0x80, 0x9c, 0x68, 0xc8, 0x60, 0x2d, 0xa1, 0xb3, 0x1c, 0xea, 0x56, 0xd5, 0x3e, 0x37,
+	0x28, 0x6d, 0x07, 0xd6, 0xaf, 0x4f, 0xc4, 0x1b, 0x2e, 0xf6, 0x1d, 0x28, 0x47, 0x7a, 0x1a, 0xf8,
-	0x16, 0x27, 0xe0, 0x53, 0x87, 0x9c, 0xb8, 0xcd, 0x26, 0x2c, 0x1a, 0xe9, 0x52, 0xd4, 0xc6, 0xe3,
+	0xd5, 0x31, 0x76, 0x1c, 0xbd, 0x32, 0x3b, 0x4c, 0x92, 0x5d, 0xa8, 0xc4, 0xee, 0xb1, 0xd3, 0x6c,
-	0xf0, 0xeb, 0xb0, 0x76, 0x01, 0xef, 0x42, 0x96, 0x5f, 0x63, 0xb1, 0x3a, 0x15, 0x85, 0xaf, 0xb8,
+	0x58, 0xd2, 0x5e, 0xa8, 0x5f, 0x9b, 0x84, 0x35, 0xdc, 0x40, 0x17, 0x2a, 0xb1, 0x5b, 0xc5, 0x94,
-	0xc7, 0xc9, 0xfc, 0x63, 0x04, 0xd5, 0xa4, 0x7b, 0x0a, 0x4e, 0x3c, 0x85, 0xc6, 0x5d, 0xb6, 0x6a,
+	0x95, 0x64, 0x97, 0xa8, 0x29, 0x2b, 0x49, 0x2f, 0x29, 0xd5, 0x33, 0xf8, 0xfb, 0x91, 0x0b, 0xcc,
-	0xb7, 0x4f, 0x48, 0x15, 0xa8, 0xea, 0x19, 0xcc, 0x2b, 0xaa, 0x63, 0xbc, 0x9e, 0xb4, 0x5e, 0x42,
+	0xd8, 0x25, 0x31, 0xfe, 0xe2, 0xd8, 0x79, 0x64, 0x77, 0xe4, 0xf5, 0xb5, 0xa3, 0x0c, 0x09, 0x21,
-	0x61, 0x5f, 0x7b, 0x73, 0x72, 0x82, 0x60, 0x6f, 0x02, 0xa5, 0x70, 0xc1, 0x9b, 0x70, 0x1c, 0x28,
+	0xbc, 0x03, 0xa5, 0xf0, 0xf2, 0x12, 0x5f, 0x49, 0x0d, 0x0b, 0x47, 0xd1, 0x54, 0x13, 0x0a, 0xe2,
-	0x6a, 0xe5, 0xda, 0xb5, 0x09, 0x30, 0x87, 0xdb, 0x6c, 0xf4, 0xa1, 0xb4, 0xe7, 0xb9, 0x4f, 0x07,
+	0x22, 0x0d, 0xab, 0x29, 0x1d, 0x81, 0xc8, 0x2d, 0x63, 0xfd, 0xe5, 0xb1, 0x3c, 0x21, 0x4e, 0x0d,
-	0xc3, 0x82, 0xf4, 0xb3, 0xd9, 0x76, 0xeb, 0xf6, 0x77, 0x37, 0xf7, 0x2d, 0xbf, 0xd3, 0x6f, 0x31,
+	0x0a, 0xa2, 0x9a, 0x4d, 0x99, 0x34, 0x76, 0xbb, 0x54, 0x1f, 0xcf, 0xc3, 0xcb, 0x61, 0xf5, 0x0c,
-	0xfb, 0xaf, 0x0b, 0xdc, 0x37, 0x2c, 0x57, 0x3e, 0xad, 0x5b, 0x8e, 0x4f, 0x3c, 0xc7, 0xb0, 0xd7,
+	0x7e, 0x0f, 0x8a, 0xc1, 0x1d, 0x01, 0x7e, 0x25, 0xc5, 0xed, 0x63, 0x97, 0x28, 0xf5, 0xc3, 0xb8,
-	0xf9, 0x5a, 0x12, 0xda, 0x6b, 0xb5, 0x72, 0xfc, 0x7d, 0xf3, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0x82, 0x99, 0xb7, 0x21, 0xcf, 0x0b, 0x64, 0x2c, 0x0f, 0x72, 0xd1, 0xe2, 0xf9, 0x30, 0x69, 0xfe,
-	0x20, 0x11, 0x9c, 0x73, 0xcc, 0x2c, 0x00, 0x00,
+	0x18, 0x41, 0x2d, 0xad, 0x02, 0xc2, 0xa9, 0xe7, 0xdb, 0xb8, 0x32, 0xae, 0x7e, 0xeb, 0x88, 0xa3,
+	0x42, 0x25, 0x3c, 0x85, 0x79, 0x49, 0xde, 0x8d, 0x57, 0xd3, 0xe6, 0x4b, 0x29, 0x19, 0xea, 0x6f,
+	0x4c, 0x3e, 0x20, 0x5c, 0x9b, 0x80, 0x12, 0x4d, 0xa5, 0x53, 0x0e, 0x1a, 0x49, 0x16, 0x5e, 0xbf,
+	0x3a, 0x01, 0x67, 0xb0, 0xcc, 0xda, 0x00, 0x94, 0x1d, 0xd7, 0x79, 0x32, 0x0c, 0x52, 0xdd, 0xcf,
+	0x67, 0xd9, 0x8d, 0x5b, 0xdf, 0x5d, 0xdf, 0x35, 0xbd, 0xee, 0xa0, 0xcd, 0xf4, 0xbf, 0x2a, 0x78,
+	0x5f, 0x37, 0x1d, 0xff, 0x69, 0xd5, 0xb4, 0x3d, 0xe2, 0xda, 0xba, 0xb5, 0xca, 0xe7, 0xf2, 0xa9,
+	0xfd, 0x76, 0xbb, 0xc0, 0xdf, 0xd7, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x78, 0xd5, 0xe7, 0xcd,
+	0xde, 0x2e, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3310,6 +3453,7 @@ type MilvusServiceClient interface {
 	DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	Insert(ctx context.Context, in *InsertRequest, opts ...grpc.CallOption) (*InsertResponse, error)
 	Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResults, error)
+	Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error)
 	Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error)
 	GetQuerySegmentInfo(ctx context.Context, in *GetQuerySegmentInfoRequest, opts ...grpc.CallOption) (*GetQuerySegmentInfoResponse, error)
@@ -3523,6 +3667,15 @@ func (c *milvusServiceClient) Search(ctx context.Context, in *SearchRequest, opt
 	return out, nil
 }
 
+func (c *milvusServiceClient) Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error) {
+	out := new(RetrieveResults)
+	err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/Retrieve", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *milvusServiceClient) Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	out := new(commonpb.Status)
 	err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/Flush", in, out, opts...)
@@ -3583,6 +3736,7 @@ type MilvusServiceServer interface {
 	DropIndex(context.Context, *DropIndexRequest) (*commonpb.Status, error)
 	Insert(context.Context, *InsertRequest) (*InsertResponse, error)
 	Search(context.Context, *SearchRequest) (*SearchResults, error)
+	Retrieve(context.Context, *RetrieveRequest) (*RetrieveResults, error)
 	Flush(context.Context, *FlushRequest) (*commonpb.Status, error)
 	GetPersistentSegmentInfo(context.Context, *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error)
 	GetQuerySegmentInfo(context.Context, *GetQuerySegmentInfoRequest) (*GetQuerySegmentInfoResponse, error)
@@ -3660,6 +3814,9 @@ func (*UnimplementedMilvusServiceServer) Insert(ctx context.Context, req *Insert
 func (*UnimplementedMilvusServiceServer) Search(ctx context.Context, req *SearchRequest) (*SearchResults, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Search not implemented")
 }
+func (*UnimplementedMilvusServiceServer) Retrieve(ctx context.Context, req *RetrieveRequest) (*RetrieveResults, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Retrieve not implemented")
+}
 func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRequest) (*commonpb.Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented")
 }
@@ -4073,6 +4230,24 @@ func _MilvusService_Search_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _MilvusService_Retrieve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RetrieveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MilvusServiceServer).Retrieve(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.milvus.MilvusService/Retrieve",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MilvusServiceServer).Retrieve(ctx, req.(*RetrieveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _MilvusService_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FlushRequest)
 	if err := dec(in); err != nil {
@@ -4237,6 +4412,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Search",
 			Handler:    _MilvusService_Search_Handler,
 		},
+		{
+			MethodName: "Retrieve",
+			Handler:    _MilvusService_Retrieve_Handler,
+		},
 		{
 			MethodName: "Flush",
 			Handler:    _MilvusService_Flush_Handler,

internal/proto/schema.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package milvus.proto.schema;
-option go_package="github.com/milvus-io/milvus/internal/proto/schemapb";
+option go_package = "github.com/milvus-io/milvus/internal/proto/schemapb";
 
 import "common.proto";
 
@@ -47,3 +47,68 @@ message CollectionSchema {
   bool autoID = 3;
   repeated FieldSchema fields = 4;
 }
+
+message BoolArray {
+  repeated bool data = 1;
+}
+
+message IntArray {
+  repeated int32 data = 1;
+}
+
+message LongArray {
+  repeated int64 data = 1;
+}
+
+message FloatArray {
+  repeated float data = 1;
+}
+
+message DoubleArray {
+  repeated double data = 1;
+}
+
+// For special fields such as bigdecimal, array...
+message BytesArray {
+  repeated bytes data = 1;
+}
+
+message StringArray {
+  repeated string data = 1;
+}
+
+message ScalarField {
+  oneof data {
+    BoolArray bool_data = 1;
+    IntArray int_data = 2;
+    LongArray long_data = 3;
+    FloatArray float_data = 4;
+    DoubleArray double_data = 5;
+    StringArray string_data = 6;
+    BytesArray bytes_data = 7;
+  }
+}
+
+message VectorField {
+  int64 dim = 1;
+  oneof data {
+    FloatArray float_vector = 2;
+    bytes binary_vector = 3;
+  }
+}
+
+message FieldData {
+  DataType type = 1;
+  string field_name = 2;
+  oneof field {
+    ScalarField scalars = 3;
+    VectorField vectors = 4;
+  }
+}
+
+message IDs {
+  oneof id_field {
+    LongArray int_id = 1;
+    StringArray str_id = 2;
+  }
+}

internal/proto/schemapb/schema.pb.go

@@ -229,42 +229,771 @@ func (m *CollectionSchema) GetFields() []*FieldSchema {
 	return nil
 }
 
+type BoolArray struct {
+	Data                 []bool   `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BoolArray) Reset()         { *m = BoolArray{} }
+func (m *BoolArray) String() string { return proto.CompactTextString(m) }
+func (*BoolArray) ProtoMessage()    {}
+func (*BoolArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{2}
+}
+
+func (m *BoolArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BoolArray.Unmarshal(m, b)
+}
+func (m *BoolArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BoolArray.Marshal(b, m, deterministic)
+}
+func (m *BoolArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BoolArray.Merge(m, src)
+}
+func (m *BoolArray) XXX_Size() int {
+	return xxx_messageInfo_BoolArray.Size(m)
+}
+func (m *BoolArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_BoolArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BoolArray proto.InternalMessageInfo
+
+func (m *BoolArray) GetData() []bool {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type IntArray struct {
+	Data                 []int32  `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *IntArray) Reset()         { *m = IntArray{} }
+func (m *IntArray) String() string { return proto.CompactTextString(m) }
+func (*IntArray) ProtoMessage()    {}
+func (*IntArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{3}
+}
+
+func (m *IntArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IntArray.Unmarshal(m, b)
+}
+func (m *IntArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IntArray.Marshal(b, m, deterministic)
+}
+func (m *IntArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IntArray.Merge(m, src)
+}
+func (m *IntArray) XXX_Size() int {
+	return xxx_messageInfo_IntArray.Size(m)
+}
+func (m *IntArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_IntArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IntArray proto.InternalMessageInfo
+
+func (m *IntArray) GetData() []int32 {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type LongArray struct {
+	Data                 []int64  `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LongArray) Reset()         { *m = LongArray{} }
+func (m *LongArray) String() string { return proto.CompactTextString(m) }
+func (*LongArray) ProtoMessage()    {}
+func (*LongArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{4}
+}
+
+func (m *LongArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_LongArray.Unmarshal(m, b)
+}
+func (m *LongArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_LongArray.Marshal(b, m, deterministic)
+}
+func (m *LongArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_LongArray.Merge(m, src)
+}
+func (m *LongArray) XXX_Size() int {
+	return xxx_messageInfo_LongArray.Size(m)
+}
+func (m *LongArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_LongArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LongArray proto.InternalMessageInfo
+
+func (m *LongArray) GetData() []int64 {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type FloatArray struct {
+	Data                 []float32 `protobuf:"fixed32,1,rep,packed,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *FloatArray) Reset()         { *m = FloatArray{} }
+func (m *FloatArray) String() string { return proto.CompactTextString(m) }
+func (*FloatArray) ProtoMessage()    {}
+func (*FloatArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{5}
+}
+
+func (m *FloatArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FloatArray.Unmarshal(m, b)
+}
+func (m *FloatArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FloatArray.Marshal(b, m, deterministic)
+}
+func (m *FloatArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FloatArray.Merge(m, src)
+}
+func (m *FloatArray) XXX_Size() int {
+	return xxx_messageInfo_FloatArray.Size(m)
+}
+func (m *FloatArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_FloatArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FloatArray proto.InternalMessageInfo
+
+func (m *FloatArray) GetData() []float32 {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type DoubleArray struct {
+	Data                 []float64 `protobuf:"fixed64,1,rep,packed,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *DoubleArray) Reset()         { *m = DoubleArray{} }
+func (m *DoubleArray) String() string { return proto.CompactTextString(m) }
+func (*DoubleArray) ProtoMessage()    {}
+func (*DoubleArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{6}
+}
+
+func (m *DoubleArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DoubleArray.Unmarshal(m, b)
+}
+func (m *DoubleArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DoubleArray.Marshal(b, m, deterministic)
+}
+func (m *DoubleArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DoubleArray.Merge(m, src)
+}
+func (m *DoubleArray) XXX_Size() int {
+	return xxx_messageInfo_DoubleArray.Size(m)
+}
+func (m *DoubleArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_DoubleArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DoubleArray proto.InternalMessageInfo
+
+func (m *DoubleArray) GetData() []float64 {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// For special fields such as bigdecimal, array...
+type BytesArray struct {
+	Data                 [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BytesArray) Reset()         { *m = BytesArray{} }
+func (m *BytesArray) String() string { return proto.CompactTextString(m) }
+func (*BytesArray) ProtoMessage()    {}
+func (*BytesArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{7}
+}
+
+func (m *BytesArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BytesArray.Unmarshal(m, b)
+}
+func (m *BytesArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BytesArray.Marshal(b, m, deterministic)
+}
+func (m *BytesArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BytesArray.Merge(m, src)
+}
+func (m *BytesArray) XXX_Size() int {
+	return xxx_messageInfo_BytesArray.Size(m)
+}
+func (m *BytesArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_BytesArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BytesArray proto.InternalMessageInfo
+
+func (m *BytesArray) GetData() [][]byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type StringArray struct {
+	Data                 []string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StringArray) Reset()         { *m = StringArray{} }
+func (m *StringArray) String() string { return proto.CompactTextString(m) }
+func (*StringArray) ProtoMessage()    {}
+func (*StringArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{8}
+}
+
+func (m *StringArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StringArray.Unmarshal(m, b)
+}
+func (m *StringArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StringArray.Marshal(b, m, deterministic)
+}
+func (m *StringArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StringArray.Merge(m, src)
+}
+func (m *StringArray) XXX_Size() int {
+	return xxx_messageInfo_StringArray.Size(m)
+}
+func (m *StringArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_StringArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StringArray proto.InternalMessageInfo
+
+func (m *StringArray) GetData() []string {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type ScalarField struct {
+	// Types that are valid to be assigned to Data:
+	//	*ScalarField_BoolData
+	//	*ScalarField_IntData
+	//	*ScalarField_LongData
+	//	*ScalarField_FloatData
+	//	*ScalarField_DoubleData
+	//	*ScalarField_StringData
+	//	*ScalarField_BytesData
+	Data                 isScalarField_Data `protobuf_oneof:"data"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *ScalarField) Reset()         { *m = ScalarField{} }
+func (m *ScalarField) String() string { return proto.CompactTextString(m) }
+func (*ScalarField) ProtoMessage()    {}
+func (*ScalarField) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{9}
+}
+
+func (m *ScalarField) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ScalarField.Unmarshal(m, b)
+}
+func (m *ScalarField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ScalarField.Marshal(b, m, deterministic)
+}
+func (m *ScalarField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ScalarField.Merge(m, src)
+}
+func (m *ScalarField) XXX_Size() int {
+	return xxx_messageInfo_ScalarField.Size(m)
+}
+func (m *ScalarField) XXX_DiscardUnknown() {
+	xxx_messageInfo_ScalarField.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ScalarField proto.InternalMessageInfo
+
+type isScalarField_Data interface {
+	isScalarField_Data()
+}
+
+type ScalarField_BoolData struct {
+	BoolData *BoolArray `protobuf:"bytes,1,opt,name=bool_data,json=boolData,proto3,oneof"`
+}
+
+type ScalarField_IntData struct {
+	IntData *IntArray `protobuf:"bytes,2,opt,name=int_data,json=intData,proto3,oneof"`
+}
+
+type ScalarField_LongData struct {
+	LongData *LongArray `protobuf:"bytes,3,opt,name=long_data,json=longData,proto3,oneof"`
+}
+
+type ScalarField_FloatData struct {
+	FloatData *FloatArray `protobuf:"bytes,4,opt,name=float_data,json=floatData,proto3,oneof"`
+}
+
+type ScalarField_DoubleData struct {
+	DoubleData *DoubleArray `protobuf:"bytes,5,opt,name=double_data,json=doubleData,proto3,oneof"`
+}
+
+type ScalarField_StringData struct {
+	StringData *StringArray `protobuf:"bytes,6,opt,name=string_data,json=stringData,proto3,oneof"`
+}
+
+type ScalarField_BytesData struct {
+	BytesData *BytesArray `protobuf:"bytes,7,opt,name=bytes_data,json=bytesData,proto3,oneof"`
+}
+
+func (*ScalarField_BoolData) isScalarField_Data() {}
+
+func (*ScalarField_IntData) isScalarField_Data() {}
+
+func (*ScalarField_LongData) isScalarField_Data() {}
+
+func (*ScalarField_FloatData) isScalarField_Data() {}
+
+func (*ScalarField_DoubleData) isScalarField_Data() {}
+
+func (*ScalarField_StringData) isScalarField_Data() {}
+
+func (*ScalarField_BytesData) isScalarField_Data() {}
+
+func (m *ScalarField) GetData() isScalarField_Data {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *ScalarField) GetBoolData() *BoolArray {
+	if x, ok := m.GetData().(*ScalarField_BoolData); ok {
+		return x.BoolData
+	}
+	return nil
+}
+
+func (m *ScalarField) GetIntData() *IntArray {
+	if x, ok := m.GetData().(*ScalarField_IntData); ok {
+		return x.IntData
+	}
+	return nil
+}
+
+func (m *ScalarField) GetLongData() *LongArray {
+	if x, ok := m.GetData().(*ScalarField_LongData); ok {
+		return x.LongData
+	}
+	return nil
+}
+
+func (m *ScalarField) GetFloatData() *FloatArray {
+	if x, ok := m.GetData().(*ScalarField_FloatData); ok {
+		return x.FloatData
+	}
+	return nil
+}
+
+func (m *ScalarField) GetDoubleData() *DoubleArray {
+	if x, ok := m.GetData().(*ScalarField_DoubleData); ok {
+		return x.DoubleData
+	}
+	return nil
+}
+
+func (m *ScalarField) GetStringData() *StringArray {
+	if x, ok := m.GetData().(*ScalarField_StringData); ok {
+		return x.StringData
+	}
+	return nil
+}
+
+func (m *ScalarField) GetBytesData() *BytesArray {
+	if x, ok := m.GetData().(*ScalarField_BytesData); ok {
+		return x.BytesData
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*ScalarField) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*ScalarField_BoolData)(nil),
+		(*ScalarField_IntData)(nil),
+		(*ScalarField_LongData)(nil),
+		(*ScalarField_FloatData)(nil),
+		(*ScalarField_DoubleData)(nil),
+		(*ScalarField_StringData)(nil),
+		(*ScalarField_BytesData)(nil),
+	}
+}
+
+type VectorField struct {
+	Dim int64 `protobuf:"varint,1,opt,name=dim,proto3" json:"dim,omitempty"`
+	// Types that are valid to be assigned to Data:
+	//	*VectorField_FloatVector
+	//	*VectorField_BinaryVector
+	Data                 isVectorField_Data `protobuf_oneof:"data"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *VectorField) Reset()         { *m = VectorField{} }
+func (m *VectorField) String() string { return proto.CompactTextString(m) }
+func (*VectorField) ProtoMessage()    {}
+func (*VectorField) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{10}
+}
+
+func (m *VectorField) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VectorField.Unmarshal(m, b)
+}
+func (m *VectorField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VectorField.Marshal(b, m, deterministic)
+}
+func (m *VectorField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VectorField.Merge(m, src)
+}
+func (m *VectorField) XXX_Size() int {
+	return xxx_messageInfo_VectorField.Size(m)
+}
+func (m *VectorField) XXX_DiscardUnknown() {
+	xxx_messageInfo_VectorField.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VectorField proto.InternalMessageInfo
+
+func (m *VectorField) GetDim() int64 {
+	if m != nil {
+		return m.Dim
+	}
+	return 0
+}
+
+type isVectorField_Data interface {
+	isVectorField_Data()
+}
+
+type VectorField_FloatVector struct {
+	FloatVector *FloatArray `protobuf:"bytes,2,opt,name=float_vector,json=floatVector,proto3,oneof"`
+}
+
+type VectorField_BinaryVector struct {
+	BinaryVector []byte `protobuf:"bytes,3,opt,name=binary_vector,json=binaryVector,proto3,oneof"`
+}
+
+func (*VectorField_FloatVector) isVectorField_Data() {}
+
+func (*VectorField_BinaryVector) isVectorField_Data() {}
+
+func (m *VectorField) GetData() isVectorField_Data {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *VectorField) GetFloatVector() *FloatArray {
+	if x, ok := m.GetData().(*VectorField_FloatVector); ok {
+		return x.FloatVector
+	}
+	return nil
+}
+
+func (m *VectorField) GetBinaryVector() []byte {
+	if x, ok := m.GetData().(*VectorField_BinaryVector); ok {
+		return x.BinaryVector
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*VectorField) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*VectorField_FloatVector)(nil),
+		(*VectorField_BinaryVector)(nil),
+	}
+}
+
+type FieldData struct {
+	Type      DataType `protobuf:"varint,1,opt,name=type,proto3,enum=milvus.proto.schema.DataType" json:"type,omitempty"`
+	FieldName string   `protobuf:"bytes,2,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
+	// Types that are valid to be assigned to Field:
+	//	*FieldData_Scalars
+	//	*FieldData_Vectors
+	Field                isFieldData_Field `protobuf_oneof:"field"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *FieldData) Reset()         { *m = FieldData{} }
+func (m *FieldData) String() string { return proto.CompactTextString(m) }
+func (*FieldData) ProtoMessage()    {}
+func (*FieldData) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{11}
+}
+
+func (m *FieldData) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FieldData.Unmarshal(m, b)
+}
+func (m *FieldData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FieldData.Marshal(b, m, deterministic)
+}
+func (m *FieldData) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldData.Merge(m, src)
+}
+func (m *FieldData) XXX_Size() int {
+	return xxx_messageInfo_FieldData.Size(m)
+}
+func (m *FieldData) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldData.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldData proto.InternalMessageInfo
+
+func (m *FieldData) GetType() DataType {
+	if m != nil {
+		return m.Type
+	}
+	return DataType_None
+}
+
+func (m *FieldData) GetFieldName() string {
+	if m != nil {
+		return m.FieldName
+	}
+	return ""
+}
+
+type isFieldData_Field interface {
+	isFieldData_Field()
+}
+
+type FieldData_Scalars struct {
+	Scalars *ScalarField `protobuf:"bytes,3,opt,name=scalars,proto3,oneof"`
+}
+
+type FieldData_Vectors struct {
+	Vectors *VectorField `protobuf:"bytes,4,opt,name=vectors,proto3,oneof"`
+}
+
+func (*FieldData_Scalars) isFieldData_Field() {}
+
+func (*FieldData_Vectors) isFieldData_Field() {}
+
+func (m *FieldData) GetField() isFieldData_Field {
+	if m != nil {
+		return m.Field
+	}
+	return nil
+}
+
+func (m *FieldData) GetScalars() *ScalarField {
+	if x, ok := m.GetField().(*FieldData_Scalars); ok {
+		return x.Scalars
+	}
+	return nil
+}
+
+func (m *FieldData) GetVectors() *VectorField {
+	if x, ok := m.GetField().(*FieldData_Vectors); ok {
+		return x.Vectors
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*FieldData) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*FieldData_Scalars)(nil),
+		(*FieldData_Vectors)(nil),
+	}
+}
+
+type IDs struct {
+	// Types that are valid to be assigned to IdField:
+	//	*IDs_IntId
+	//	*IDs_StrId
+	IdField              isIDs_IdField `protobuf_oneof:"id_field"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *IDs) Reset()         { *m = IDs{} }
+func (m *IDs) String() string { return proto.CompactTextString(m) }
+func (*IDs) ProtoMessage()    {}
+func (*IDs) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1c5fb4d8cc22d66a, []int{12}
+}
+
+func (m *IDs) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IDs.Unmarshal(m, b)
+}
+func (m *IDs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IDs.Marshal(b, m, deterministic)
+}
+func (m *IDs) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IDs.Merge(m, src)
+}
+func (m *IDs) XXX_Size() int {
+	return xxx_messageInfo_IDs.Size(m)
+}
+func (m *IDs) XXX_DiscardUnknown() {
+	xxx_messageInfo_IDs.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IDs proto.InternalMessageInfo
+
+type isIDs_IdField interface {
+	isIDs_IdField()
+}
+
+type IDs_IntId struct {
+	IntId *LongArray `protobuf:"bytes,1,opt,name=int_id,json=intId,proto3,oneof"`
+}
+
+type IDs_StrId struct {
+	StrId *StringArray `protobuf:"bytes,2,opt,name=str_id,json=strId,proto3,oneof"`
+}
+
+func (*IDs_IntId) isIDs_IdField() {}
+
+func (*IDs_StrId) isIDs_IdField() {}
+
+func (m *IDs) GetIdField() isIDs_IdField {
+	if m != nil {
+		return m.IdField
+	}
+	return nil
+}
+
+func (m *IDs) GetIntId() *LongArray {
+	if x, ok := m.GetIdField().(*IDs_IntId); ok {
+		return x.IntId
+	}
+	return nil
+}
+
+func (m *IDs) GetStrId() *StringArray {
+	if x, ok := m.GetIdField().(*IDs_StrId); ok {
+		return x.StrId
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*IDs) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*IDs_IntId)(nil),
+		(*IDs_StrId)(nil),
+	}
+}
+
 func init() {
 	proto.RegisterEnum("milvus.proto.schema.DataType", DataType_name, DataType_value)
 	proto.RegisterType((*FieldSchema)(nil), "milvus.proto.schema.FieldSchema")
 	proto.RegisterType((*CollectionSchema)(nil), "milvus.proto.schema.CollectionSchema")
+	proto.RegisterType((*BoolArray)(nil), "milvus.proto.schema.BoolArray")
+	proto.RegisterType((*IntArray)(nil), "milvus.proto.schema.IntArray")
+	proto.RegisterType((*LongArray)(nil), "milvus.proto.schema.LongArray")
+	proto.RegisterType((*FloatArray)(nil), "milvus.proto.schema.FloatArray")
+	proto.RegisterType((*DoubleArray)(nil), "milvus.proto.schema.DoubleArray")
+	proto.RegisterType((*BytesArray)(nil), "milvus.proto.schema.BytesArray")
+	proto.RegisterType((*StringArray)(nil), "milvus.proto.schema.StringArray")
+	proto.RegisterType((*ScalarField)(nil), "milvus.proto.schema.ScalarField")
+	proto.RegisterType((*VectorField)(nil), "milvus.proto.schema.VectorField")
+	proto.RegisterType((*FieldData)(nil), "milvus.proto.schema.FieldData")
+	proto.RegisterType((*IDs)(nil), "milvus.proto.schema.IDs")
 }
 
 func init() { proto.RegisterFile("schema.proto", fileDescriptor_1c5fb4d8cc22d66a) }
 
 var fileDescriptor_1c5fb4d8cc22d66a = []byte{
-	// 443 bytes of a gzipped FileDescriptorProto
+	// 842 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x91, 0x41, 0x8b, 0xd4, 0x30,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xd1, 0x8e, 0xdb, 0x44,
-	0x1c, 0xc5, 0xcd, 0x4c, 0xa7, 0x3b, 0xf3, 0x6f, 0x59, 0x43, 0x14, 0x29, 0x82, 0x50, 0x17, 0x0f,
+	0x14, 0xcd, 0xc4, 0x89, 0x63, 0x5f, 0x87, 0x62, 0x0d, 0x08, 0x59, 0x48, 0xed, 0xba, 0x11, 0x48,
-	0x45, 0x70, 0x06, 0x67, 0x74, 0x59, 0x3c, 0x8e, 0x65, 0x61, 0x58, 0x90, 0xa1, 0x2b, 0x7b, 0xf0,
+	0x11, 0x12, 0xbb, 0xea, 0x2e, 0x94, 0x52, 0x51, 0x09, 0xd2, 0x68, 0x95, 0xa8, 0xa8, 0x5a, 0x79,
-	0x32, 0x64, 0xda, 0xb8, 0x1b, 0x4c, 0x93, 0x92, 0xa6, 0x62, 0x3f, 0x85, 0x77, 0xbf, 0x91, 0xdf,
+	0x51, 0x1f, 0x78, 0x89, 0x26, 0xf1, 0x74, 0x3b, 0xc2, 0x99, 0x89, 0xec, 0xc9, 0x0a, 0x7f, 0x00,
-	0x4a, 0x92, 0x66, 0x60, 0xd4, 0x3d, 0xec, 0xed, 0xbd, 0x7f, 0xf2, 0xfe, 0xe4, 0xfd, 0x02, 0x71,
+	0xcf, 0xbc, 0xf0, 0xc4, 0x1f, 0xf1, 0x11, 0xbc, 0xf0, 0x25, 0x68, 0xee, 0x4c, 0x36, 0x86, 0xb8,
-	0x5b, 0xde, 0xb1, 0x9a, 0xce, 0x1b, 0xad, 0x8c, 0x22, 0x4f, 0x6a, 0x2e, 0xbe, 0x77, 0xed, 0xe0,
+	0xab, 0xbc, 0xdd, 0x99, 0xb9, 0xe7, 0xf8, 0xde, 0x73, 0xcf, 0x8c, 0x61, 0x58, 0xad, 0xde, 0xf1,
-	0xe6, 0xc3, 0xd1, 0xf3, 0xb8, 0x54, 0x75, 0xad, 0xe4, 0x30, 0x3c, 0xfb, 0x3d, 0x82, 0xe8, 0x92,
+	0x35, 0x3b, 0xdd, 0x94, 0x4a, 0x2b, 0xfa, 0xd1, 0x5a, 0x14, 0xb7, 0xdb, 0xca, 0xae, 0x4e, 0xed,
-	0x33, 0x51, 0x5d, 0xbb, 0x53, 0x92, 0xc0, 0xc9, 0x57, 0x6b, 0x37, 0x79, 0x82, 0x52, 0x94, 0x8d,
+	0xd1, 0xa7, 0xc3, 0x95, 0x5a, 0xaf, 0x95, 0xb4, 0x9b, 0xa3, 0xbf, 0xba, 0x10, 0x5d, 0x0a, 0x5e,
-	0x8b, 0x83, 0x25, 0x04, 0x02, 0x49, 0x6b, 0x96, 0x8c, 0x52, 0x94, 0xcd, 0x0a, 0xa7, 0xc9, 0x2b,
+	0xe4, 0xd7, 0x78, 0x4a, 0x13, 0x18, 0xbc, 0x35, 0xcb, 0xf9, 0x34, 0x21, 0x29, 0x19, 0x7b, 0xd9,
-	0x38, 0xe5, 0xed, 0xae, 0xd1, 0xbc, 0xa6, 0xba, 0xdf, 0x7d, 0x63, 0x7d, 0x32, 0x4e, 0x51, 0x36,
+	0x6e, 0x49, 0x29, 0xf4, 0x24, 0x5b, 0xf3, 0xa4, 0x9b, 0x92, 0x71, 0x98, 0x61, 0x4c, 0x3f, 0x83,
-	0x2d, 0x62, 0xde, 0x6e, 0x87, 0xe1, 0x15, 0xeb, 0x49, 0x0a, 0x51, 0xc5, 0xda, 0x52, 0xf3, 0xc6,
+	0x07, 0xa2, 0x5a, 0x6c, 0x4a, 0xb1, 0x66, 0x65, 0xbd, 0xf8, 0x85, 0xd7, 0x89, 0x97, 0x92, 0x71,
-	0x70, 0x25, 0x93, 0xc0, 0x2d, 0x38, 0x1e, 0x91, 0x0f, 0x30, 0xab, 0xa8, 0xa1, 0x3b, 0xd3, 0x37,
+	0x90, 0x0d, 0x45, 0x75, 0x65, 0x37, 0x5f, 0xf1, 0x9a, 0xa6, 0x10, 0xe5, 0xbc, 0x5a, 0x95, 0x62,
-	0x2c, 0x99, 0xa4, 0x28, 0x3b, 0x5d, 0xbe, 0x98, 0xdf, 0xf3, 0xf8, 0x79, 0x4e, 0x0d, 0xfd, 0xdc,
+	0xa3, 0x85, 0x92, 0x49, 0x0f, 0x09, 0x9a, 0x5b, 0xf4, 0x39, 0x84, 0x39, 0xd3, 0x6c, 0xa1, 0xeb,
-	0x37, 0xac, 0x98, 0x56, 0x5e, 0x91, 0x35, 0x44, 0x36, 0xb6, 0x6b, 0xa8, 0xa6, 0x75, 0x9b, 0x84,
+	0x0d, 0x4f, 0xfa, 0x29, 0x19, 0x3f, 0x38, 0x7f, 0x78, 0xda, 0x52, 0xfc, 0xe9, 0x94, 0x69, 0xf6,
-	0xe9, 0x38, 0x8b, 0x96, 0x2f, 0xff, 0x4e, 0xfb, 0xca, 0x57, 0xac, 0xbf, 0xa1, 0xa2, 0x63, 0x5b,
+	0x53, 0xbd, 0xe1, 0x59, 0x90, 0xbb, 0x88, 0x4e, 0x20, 0x32, 0xb0, 0xc5, 0x86, 0x95, 0x6c, 0x5d,
-	0xca, 0x75, 0x01, 0x36, 0xb5, 0x75, 0x21, 0x92, 0x43, 0xcc, 0x65, 0xc5, 0x7e, 0x1c, 0x96, 0x9c,
+	0x25, 0x7e, 0xea, 0x8d, 0xa3, 0xf3, 0xc7, 0xff, 0x45, 0xbb, 0x96, 0x5f, 0xf1, 0xfa, 0x0d, 0x2b,
-	0x3c, 0x74, 0x49, 0xe4, 0x62, 0xc3, 0x96, 0xb3, 0x5f, 0x08, 0xf0, 0x47, 0x25, 0x04, 0x2b, 0x6d,
+	0xb6, 0xfc, 0x8a, 0x89, 0x32, 0x03, 0x83, 0xba, 0x42, 0x10, 0x9d, 0xc2, 0x50, 0xc8, 0x9c, 0xff,
-	0x29, 0x0f, 0xf4, 0x80, 0x0d, 0x1d, 0x61, 0xfb, 0x07, 0xc8, 0xe8, 0x7f, 0x20, 0xcf, 0x20, 0xa4,
+	0xba, 0x23, 0x19, 0x1c, 0x4b, 0x12, 0x21, 0xcc, 0xb2, 0x8c, 0xfe, 0x24, 0x10, 0xbf, 0x54, 0x45,
-	0x9d, 0x51, 0x9b, 0xdc, 0x03, 0xf5, 0x8e, 0x5c, 0x40, 0xe8, 0xfe, 0xa3, 0x4d, 0x02, 0xf7, 0xc4,
+	0xc1, 0x57, 0xa6, 0x29, 0x27, 0xe8, 0x4e, 0x36, 0xd2, 0x90, 0xed, 0x7f, 0x82, 0x74, 0x0f, 0x05,
-	0xf4, 0x5e, 0x4a, 0x47, 0x1f, 0x5a, 0xf8, 0xfb, 0xaf, 0x7f, 0x22, 0x98, 0x1e, 0xe8, 0x91, 0x29,
+	0xf9, 0x04, 0x7c, 0xb6, 0xd5, 0x6a, 0x3e, 0x75, 0x82, 0xba, 0x15, 0x7d, 0x06, 0x3e, 0xce, 0xa3,
-	0x04, 0x9f, 0x94, 0x64, 0xf8, 0x91, 0x55, 0x6b, 0xa5, 0x04, 0x46, 0x56, 0x6d, 0xa4, 0xb9, 0xc0,
+	0x4a, 0x7a, 0x58, 0x62, 0xda, 0xaa, 0x52, 0x63, 0xa0, 0x99, 0xcb, 0x1f, 0x9d, 0x40, 0x38, 0x51,
-	0x23, 0x32, 0x83, 0xc9, 0x46, 0x9a, 0xb7, 0xe7, 0x78, 0xec, 0xe5, 0x6a, 0x89, 0x03, 0x2f, 0xcf,
+	0xaa, 0xf8, 0xa1, 0x2c, 0x59, 0x6d, 0x8a, 0x32, 0xfa, 0x25, 0x24, 0xf5, 0xc6, 0x41, 0x86, 0xf1,
-	0xdf, 0xe1, 0x89, 0x95, 0x97, 0x42, 0x51, 0x83, 0x81, 0x00, 0x84, 0xb9, 0xea, 0xf6, 0x82, 0xe1,
+	0xe8, 0x11, 0x04, 0x73, 0xa9, 0x0f, 0xcf, 0xfb, 0xee, 0xfc, 0x04, 0xc2, 0x1f, 0x95, 0xbc, 0x39,
-	0xc8, 0xea, 0x6b, 0xa3, 0xb9, 0xbc, 0xc5, 0x4f, 0x09, 0x86, 0x78, 0xcd, 0x25, 0xd5, 0xfd, 0x0d,
+	0x4c, 0xf0, 0x5c, 0x42, 0x0a, 0x70, 0x59, 0x28, 0xd6, 0x42, 0xd1, 0x75, 0x19, 0x8f, 0x21, 0x9a,
-	0x2b, 0x8d, 0xd2, 0xb8, 0x22, 0x8f, 0x21, 0x72, 0x21, 0x3f, 0x60, 0xeb, 0xf7, 0x5f, 0x56, 0xb7,
+	0xaa, 0xed, 0xb2, 0xe0, 0x87, 0x29, 0x64, 0x4f, 0x32, 0xa9, 0x35, 0xaf, 0x0e, 0x33, 0x86, 0x7b,
-	0xdc, 0xdc, 0x75, 0x7b, 0x4b, 0x76, 0x31, 0xf4, 0x78, 0xc3, 0x95, 0x57, 0x0b, 0x2e, 0x0d, 0xd3,
+	0x92, 0x6b, 0x5d, 0x8a, 0xb6, 0x4a, 0x42, 0x97, 0xf2, 0xb7, 0x07, 0xd1, 0xf5, 0x8a, 0x15, 0xac,
-	0x92, 0x8a, 0x85, 0xab, 0xb6, 0x18, 0xaa, 0x35, 0xfb, 0x7d, 0xe8, 0xfc, 0xea, 0x4f, 0x00, 0x00,
+	0x44, 0x25, 0xe8, 0x0b, 0x08, 0x97, 0x4a, 0x15, 0x0b, 0x97, 0x48, 0xc6, 0xd1, 0xf9, 0xa3, 0x56,
-	0x00, 0xff, 0xff, 0xa8, 0x56, 0xc7, 0x76, 0xeb, 0x02, 0x00, 0x00,
+	0xe1, 0xee, 0x14, 0x9a, 0x75, 0xb2, 0xc0, 0x40, 0x8c, 0xdf, 0xe8, 0x73, 0x08, 0x84, 0xd4, 0x16,
+	0xdd, 0x45, 0x74, 0xbb, 0x39, 0x77, 0xf2, 0xcd, 0x3a, 0xd9, 0x40, 0x48, 0x8d, 0xd8, 0x17, 0x10,
+	0x16, 0x4a, 0xde, 0x58, 0xb0, 0x77, 0xcf, 0xa7, 0xef, 0xb4, 0x35, 0x9f, 0x36, 0x10, 0x84, 0x7f,
+	0x0f, 0xf0, 0xd6, 0x68, 0x6a, 0xf1, 0x3d, 0xc4, 0x9f, 0xb4, 0xcf, 0xfc, 0x4e, 0xfa, 0x59, 0x27,
+	0x0b, 0x11, 0x84, 0x0c, 0x2f, 0x21, 0xca, 0x51, 0x73, 0x4b, 0xd1, 0x47, 0x8a, 0x76, 0xdb, 0x34,
+	0x66, 0x33, 0xeb, 0x64, 0x60, 0x61, 0x3b, 0x92, 0x0a, 0x35, 0xb7, 0x24, 0xfe, 0x3d, 0x24, 0x8d,
+	0xd9, 0x18, 0x12, 0x0b, 0xdb, 0xf5, 0xb2, 0x34, 0xa3, 0xb5, 0x1c, 0x83, 0x7b, 0x7a, 0xd9, 0x3b,
+	0xc0, 0xf4, 0x82, 0x20, 0xc3, 0x30, 0xf1, 0xed, 0xac, 0x47, 0x7f, 0x10, 0x88, 0xde, 0xf0, 0x95,
+	0x56, 0x6e, 0xbe, 0x31, 0x78, 0xb9, 0x58, 0xbb, 0x07, 0xcb, 0x84, 0xe6, 0x42, 0x5b, 0xdd, 0x6e,
+	0x31, 0xcd, 0x8d, 0xed, 0x08, 0xe5, 0x22, 0x84, 0x59, 0x72, 0xfa, 0x39, 0x7c, 0xb0, 0x14, 0xd2,
+	0x3c, 0x6d, 0x8e, 0xc6, 0x0c, 0x70, 0x38, 0xeb, 0x64, 0x43, 0xbb, 0x6d, 0xd3, 0xee, 0xca, 0xfa,
+	0x87, 0x40, 0x88, 0x05, 0x61, 0xbb, 0x4f, 0xa0, 0x87, 0xcf, 0x19, 0x39, 0xe6, 0x39, 0xc3, 0x54,
+	0xfa, 0x10, 0x00, 0x6f, 0xeb, 0xa2, 0xf1, 0xd0, 0x86, 0xb8, 0xf3, 0xda, 0x3c, 0x1b, 0xdf, 0xc1,
+	0xa0, 0x42, 0x57, 0x57, 0xce, 0x49, 0xef, 0x99, 0xc0, 0xde, 0xf9, 0xc6, 0x89, 0x0e, 0x62, 0xd0,
+	0xb6, 0x8b, 0xca, 0xf9, 0xa8, 0x1d, 0xdd, 0xd0, 0xd5, 0xa0, 0x1d, 0x64, 0x32, 0x80, 0x3e, 0x16,
+	0x32, 0xfa, 0x8d, 0x80, 0x37, 0x9f, 0x56, 0xf4, 0x1b, 0xf0, 0xcd, 0xa5, 0x10, 0xf9, 0xbd, 0x17,
+	0xaa, 0xe9, 0xea, 0xbe, 0x90, 0x7a, 0x9e, 0xd3, 0x6f, 0xc1, 0xaf, 0x74, 0x69, 0x80, 0xdd, 0xa3,
+	0x6d, 0xd4, 0xaf, 0x74, 0x39, 0xcf, 0x27, 0x00, 0x81, 0xc8, 0x17, 0x58, 0xc7, 0x17, 0xbf, 0x13,
+	0x08, 0x76, 0xf2, 0xd1, 0x00, 0x7a, 0xaf, 0x95, 0xe4, 0x71, 0xc7, 0x44, 0xe6, 0x12, 0xc7, 0xc4,
+	0x44, 0x73, 0xa9, 0x9f, 0xc5, 0x5d, 0x1a, 0x42, 0x7f, 0x2e, 0xf5, 0x93, 0xa7, 0xb1, 0xe7, 0xc2,
+	0x8b, 0xf3, 0xb8, 0xe7, 0xc2, 0xa7, 0x5f, 0xc5, 0x7d, 0x13, 0xa2, 0x09, 0x62, 0xa0, 0x00, 0xbe,
+	0xbd, 0x06, 0x71, 0x64, 0x62, 0x5b, 0x46, 0xfc, 0x31, 0x8d, 0x61, 0x38, 0x69, 0xcc, 0x3c, 0xce,
+	0xe9, 0x87, 0x10, 0x5d, 0xee, 0xbd, 0x12, 0xf3, 0xc9, 0xd7, 0x3f, 0x5f, 0xdc, 0x08, 0xfd, 0x6e,
+	0xbb, 0x34, 0x7f, 0x8a, 0x33, 0xdb, 0xd4, 0x97, 0x42, 0xb9, 0xe8, 0x4c, 0x48, 0xcd, 0x4b, 0xc9,
+	0x8a, 0x33, 0xec, 0xf3, 0xcc, 0xf6, 0xb9, 0x59, 0x2e, 0x7d, 0x5c, 0x5f, 0xfc, 0x1b, 0x00, 0x00,
+	0xff, 0xff, 0xe1, 0x3e, 0xe2, 0x25, 0xbb, 0x07, 0x00, 0x00,
 }

internal/proxynode/impl.go

@@ -1169,6 +1169,10 @@ func (node *ProxyNode) Search(ctx context.Context, request *milvuspb.SearchReque
 	return qt.result, nil
 }
 
+func (node *ProxyNode) Retrieve(ctx context.Context, request *milvuspb.RetrieveRequest) (*milvuspb.RetrieveResults, error) {
+	return nil, nil
+}
+
 func (node *ProxyNode) Flush(ctx context.Context, request *milvuspb.FlushRequest) (*commonpb.Status, error) {
 	ft := &FlushTask{
 		ctx:          ctx,

internal/proxynode/task.go

@@ -47,6 +47,7 @@ const (
 	CreateCollectionTaskName        = "CreateCollectionTask"
 	DropCollectionTaskName          = "DropCollectionTask"
 	SearchTaskName                  = "SearchTask"
+	RetrieveTaskName                = "RetrieveTask"
 	AnnsFieldKey                    = "anns_field"
 	TopKKey                         = "topk"
 	MetricTypeKey                   = "metric_type"