Replace ChannelID with ShardName in DML Request (#8539)

Signed-off-by: Nzhenshan.cao <zhenshan.cao@zilliz.com>

internal/core/src/pb/common.pb.h

@@ -48,7 +48,7 @@ struct TableStruct_common_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[6]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -64,6 +64,9 @@ extern AddressDefaultTypeInternal _Address_default_instance_;
 class Blob;
 class BlobDefaultTypeInternal;
 extern BlobDefaultTypeInternal _Blob_default_instance_;
+class DMLMsgHeader;
+class DMLMsgHeaderDefaultTypeInternal;
+extern DMLMsgHeaderDefaultTypeInternal _DMLMsgHeader_default_instance_;
 class KeyValuePair;
 class KeyValuePairDefaultTypeInternal;
 extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_;
@@ -82,6 +85,7 @@ extern StatusDefaultTypeInternal _Status_default_instance_;
 PROTOBUF_NAMESPACE_OPEN
 template<> ::milvus::proto::common::Address* Arena::CreateMaybeMessage<::milvus::proto::common::Address>(Arena*);
 template<> ::milvus::proto::common::Blob* Arena::CreateMaybeMessage<::milvus::proto::common::Blob>(Arena*);
+template<> ::milvus::proto::common::DMLMsgHeader* Arena::CreateMaybeMessage<::milvus::proto::common::DMLMsgHeader>(Arena*);
 template<> ::milvus::proto::common::KeyValuePair* Arena::CreateMaybeMessage<::milvus::proto::common::KeyValuePair>(Arena*);
 template<> ::milvus::proto::common::MsgBase* Arena::CreateMaybeMessage<::milvus::proto::common::MsgBase>(Arena*);
 template<> ::milvus::proto::common::MsgHeader* Arena::CreateMaybeMessage<::milvus::proto::common::MsgHeader>(Arena*);
@@ -1160,6 +1164,153 @@ class MsgHeader :
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_common_2eproto;
 };
+// -------------------------------------------------------------------
+
+class DMLMsgHeader :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.DMLMsgHeader) */ {
+ public:
+  DMLMsgHeader();
+  virtual ~DMLMsgHeader();
+
+  DMLMsgHeader(const DMLMsgHeader& from);
+  DMLMsgHeader(DMLMsgHeader&& from) noexcept
+    : DMLMsgHeader() {
+    *this = ::std::move(from);
+  }
+
+  inline DMLMsgHeader& operator=(const DMLMsgHeader& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DMLMsgHeader& operator=(DMLMsgHeader&& 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 DMLMsgHeader& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DMLMsgHeader* internal_default_instance() {
+    return reinterpret_cast<const DMLMsgHeader*>(
+               &_DMLMsgHeader_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(DMLMsgHeader& a, DMLMsgHeader& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DMLMsgHeader* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DMLMsgHeader* New() const final {
+    return CreateMaybeMessage<DMLMsgHeader>(nullptr);
+  }
+
+  DMLMsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DMLMsgHeader>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const DMLMsgHeader& from);
+  void MergeFrom(const DMLMsgHeader& 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(DMLMsgHeader* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.proto.common.DMLMsgHeader";
+  }
+  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_common_2eproto);
+    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShardNameFieldNumber = 2,
+    kBaseFieldNumber = 1,
+  };
+  // string shardName = 2;
+  void clear_shardname();
+  const std::string& shardname() const;
+  void set_shardname(const std::string& value);
+  void set_shardname(std::string&& value);
+  void set_shardname(const char* value);
+  void set_shardname(const char* value, size_t size);
+  std::string* mutable_shardname();
+  std::string* release_shardname();
+  void set_allocated_shardname(std::string* shardname);
+
+  // .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);
+
+  // @@protoc_insertion_point(class_scope:milvus.proto.common.DMLMsgHeader)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shardname_;
+  ::milvus::proto::common::MsgBase* base_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_common_2eproto;
+};
 // ===================================================================
 
 
@@ -1581,6 +1732,112 @@ inline void MsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base
   // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.MsgHeader.base)
 }
 
+// -------------------------------------------------------------------
+
+// DMLMsgHeader
+
+// .milvus.proto.common.MsgBase base = 1;
+inline bool DMLMsgHeader::has_base() const {
+  return this != internal_default_instance() && base_ != nullptr;
+}
+inline void DMLMsgHeader::clear_base() {
+  if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
+    delete base_;
+  }
+  base_ = nullptr;
+}
+inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::base() const {
+  const ::milvus::proto::common::MsgBase* p = base_;
+  // @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.base)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
+      &::milvus::proto::common::_MsgBase_default_instance_);
+}
+inline ::milvus::proto::common::MsgBase* DMLMsgHeader::release_base() {
+  // @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.base)
+  
+  ::milvus::proto::common::MsgBase* temp = base_;
+  base_ = nullptr;
+  return temp;
+}
+inline ::milvus::proto::common::MsgBase* DMLMsgHeader::mutable_base() {
+  
+  if (base_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
+    base_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.base)
+  return base_;
+}
+inline void DMLMsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete 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.common.DMLMsgHeader.base)
+}
+
+// string shardName = 2;
+inline void DMLMsgHeader::clear_shardname() {
+  shardname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& DMLMsgHeader::shardname() const {
+  // @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.shardName)
+  return shardname_.GetNoArena();
+}
+inline void DMLMsgHeader::set_shardname(const std::string& value) {
+  
+  shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.proto.common.DMLMsgHeader.shardName)
+}
+inline void DMLMsgHeader::set_shardname(std::string&& value) {
+  
+  shardname_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.DMLMsgHeader.shardName)
+}
+inline void DMLMsgHeader::set_shardname(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.proto.common.DMLMsgHeader.shardName)
+}
+inline void DMLMsgHeader::set_shardname(const char* value, size_t size) {
+  
+  shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.DMLMsgHeader.shardName)
+}
+inline std::string* DMLMsgHeader::mutable_shardname() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.shardName)
+  return shardname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* DMLMsgHeader::release_shardname() {
+  // @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.shardName)
+  
+  return shardname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void DMLMsgHeader::set_allocated_shardname(std::string* shardname) {
+  if (shardname != nullptr) {
+    
+  } else {
+    
+  }
+  shardname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shardname);
+  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.shardName)
+}
+
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
 #endif  // __GNUC__
@@ -1594,6 +1851,8 @@ inline void MsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 

internal/datanode/flow_graph_insert_buffer_node.go

@@ -355,14 +355,14 @@ func (ibNode *insertBufferNode) updateSegStatesInReplica(insertMsgs []*msgstream
 		partitionID := msg.GetPartitionID()
 
 		if !ibNode.replica.hasSegment(currentSegID, true) {
-			err = ibNode.replica.addNewSegment(currentSegID, collID, partitionID, msg.GetChannelID(),
+			err = ibNode.replica.addNewSegment(currentSegID, collID, partitionID, msg.GetShardName(),
 				startPos, endPos)
 			if err != nil {
 				log.Error("add segment wrong",
 					zap.Int64("segID", currentSegID),
 					zap.Int64("collID", collID),
 					zap.Int64("partID", partitionID),
-					zap.String("chanName", msg.GetChannelID()),
+					zap.String("chanName", msg.GetShardName()),
 					zap.Error(err))
 				return
 			}

internal/datanode/mock_test.go

@@ -392,7 +392,7 @@ func (df *DataFactory) GenMsgStreamInsertMsg(idx int, chanName string) *msgstrea
 			CollectionName: "col1",
 			PartitionName:  "default",
 			SegmentID:      1,
-			ChannelID:      chanName,
+			ShardName:      chanName,
 			Timestamps:     []Timestamp{Timestamp(idx + 1000)},
 			RowIDs:         []UniqueID{UniqueID(idx)},
 			RowData:        []*commonpb.Blob{{Value: df.rawData}},

internal/msgstream/mq_msgstream_test.go

@@ -267,7 +267,7 @@ func TestStream_PulsarMsgStream_InsertRepackFunc(t *testing.T) {
 		CollectionName: "Collection",
 		PartitionName:  "Partition",
 		SegmentID:      1,
-		ChannelID:      "1",
+		ShardName:      "1",
 		Timestamps:     []Timestamp{1, 1},
 		RowIDs:         []int64{1, 3},
 		RowData:        []*commonpb.Blob{{}, {}},
@@ -988,7 +988,7 @@ func getTsMsg(msgType MsgType, reqID UniqueID) TsMsg {
 			CollectionName: "Collection",
 			PartitionName:  "Partition",
 			SegmentID:      1,
-			ChannelID:      "0",
+			ShardName:      "0",
 			Timestamps:     []Timestamp{time},
 			RowIDs:         []int64{1},
 			RowData:        []*commonpb.Blob{{}},
@@ -1007,7 +1007,7 @@ func getTsMsg(msgType MsgType, reqID UniqueID) TsMsg {
 				SourceID:  reqID,
 			},
 			CollectionName: "Collection",
-			ChannelID:      "1",
+			ShardName:      "1",
 			Timestamp:      Timestamp(1),
 		}
 		deleteMsg := &DeleteMsg{

internal/msgstream/msg_test.go

@@ -94,7 +94,7 @@ func TestInsertMsg(t *testing.T) {
 			CollectionID:   5,
 			PartitionID:    6,
 			SegmentID:      7,
-			ChannelID:      "test-channel",
+			ShardName:      "test-channel",
 			Timestamps:     []uint64{2, 1, 3},
 			RowData:        []*commonpb.Blob{},
 		},
@@ -142,7 +142,7 @@ func TestDeleteMsg(t *testing.T) {
 			},
 
 			CollectionName: "test_collection",
-			ChannelID:      "test-channel",
+			ShardName:      "test-channel",
 			Timestamp:      uint64(1),
 		},
 	}

internal/msgstream/repack_func.go

@@ -56,7 +56,7 @@ func InsertRepackFunc(tsMsgs []TsMsg, hashKeys [][]int32) (map[int32]*MsgPack, e
 				CollectionName: insertRequest.CollectionName,
 				PartitionName:  insertRequest.PartitionName,
 				SegmentID:      insertRequest.SegmentID,
-				ChannelID:      insertRequest.ChannelID,
+				ShardName:      insertRequest.ShardName,
 				Timestamps:     []uint64{insertRequest.Timestamps[index]},
 				RowIDs:         []int64{insertRequest.RowIDs[index]},
 				RowData:        []*commonpb.Blob{insertRequest.RowData[index]},

internal/msgstream/unmarshal_test.go

@@ -52,7 +52,7 @@ func Test_ProtoUnmarshalDispatcher(t *testing.T) {
 			CollectionName: "Collection",
 			PartitionName:  "Partition",
 			SegmentID:      1,
-			ChannelID:      "0",
+			ShardName:      "0",
 			Timestamps:     []Timestamp{uint64(1)},
 			RowIDs:         []int64{1},
 			RowData:        []*commonpb.Blob{{}},

internal/proto/common.proto

@@ -161,3 +161,9 @@ enum DslType {
 message MsgHeader {
     common.MsgBase base = 1;
 }
+
+// Don't Modify This. @czs
+message DMLMsgHeader {
+    common.MsgBase base = 1;
+    string shardName = 2;
+}
\ No newline at end of file

internal/proto/commonpb/common.pb.go

@@ -686,6 +686,54 @@ func (m *MsgHeader) GetBase() *MsgBase {
 	return nil
 }
 
+// Don't Modify This. @czs
+type DMLMsgHeader struct {
+	Base                 *MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	ShardName            string   `protobuf:"bytes,2,opt,name=shardName,proto3" json:"shardName,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DMLMsgHeader) Reset()         { *m = DMLMsgHeader{} }
+func (m *DMLMsgHeader) String() string { return proto.CompactTextString(m) }
+func (*DMLMsgHeader) ProtoMessage()    {}
+func (*DMLMsgHeader) Descriptor() ([]byte, []int) {
+	return fileDescriptor_555bd8c177793206, []int{6}
+}
+
+func (m *DMLMsgHeader) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DMLMsgHeader.Unmarshal(m, b)
+}
+func (m *DMLMsgHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DMLMsgHeader.Marshal(b, m, deterministic)
+}
+func (m *DMLMsgHeader) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DMLMsgHeader.Merge(m, src)
+}
+func (m *DMLMsgHeader) XXX_Size() int {
+	return xxx_messageInfo_DMLMsgHeader.Size(m)
+}
+func (m *DMLMsgHeader) XXX_DiscardUnknown() {
+	xxx_messageInfo_DMLMsgHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DMLMsgHeader proto.InternalMessageInfo
+
+func (m *DMLMsgHeader) GetBase() *MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *DMLMsgHeader) GetShardName() string {
+	if m != nil {
+		return m.ShardName
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterEnum("milvus.proto.common.ErrorCode", ErrorCode_name, ErrorCode_value)
 	proto.RegisterEnum("milvus.proto.common.IndexState", IndexState_name, IndexState_value)
@@ -698,92 +746,95 @@ func init() {
 	proto.RegisterType((*Address)(nil), "milvus.proto.common.Address")
 	proto.RegisterType((*MsgBase)(nil), "milvus.proto.common.MsgBase")
 	proto.RegisterType((*MsgHeader)(nil), "milvus.proto.common.MsgHeader")
+	proto.RegisterType((*DMLMsgHeader)(nil), "milvus.proto.common.DMLMsgHeader")
 }
 
 func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
 
 var fileDescriptor_555bd8c177793206 = []byte{
-	// 1310 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x55, 0xdb, 0x6e, 0x1b, 0xb7,
-	0x16, 0xf5, 0x68, 0x64, 0xcb, 0xa2, 0x65, 0x9b, 0xa6, 0x2f, 0x71, 0x72, 0x8c, 0x83, 0xc0, 0x4f,
-	0x81, 0x81, 0xd8, 0xe7, 0x9c, 0xe0, 0xb4, 0x4f, 0x79, 0xb0, 0x35, 0xbe, 0x08, 0x89, 0x2f, 0x1d,
-	0x39, 0x69, 0xd1, 0x97, 0x80, 0x9e, 0xd9, 0x92, 0xd8, 0xcc, 0x90, 0x2a, 0xc9, 0x71, 0xac, 0xbf,
-	0x68, 0xf3, 0x1d, 0x6d, 0xd1, 0x4b, 0x7a, 0x41, 0xbf, 0xa0, 0xf7, 0xe7, 0x7e, 0x42, 0x3f, 0xa0,
-	0xd7, 0x5c, 0x8b, 0xcd, 0x19, 0x49, 0x13, 0x20, 0x7d, 0x9b, 0xbd, 0xb8, 0xb9, 0xb8, 0xf6, 0xda,
-	0x9b, 0x1c, 0xd2, 0x88, 0x54, 0x9a, 0x2a, 0xb9, 0xd9, 0xd7, 0xca, 0x2a, 0xb6, 0x98, 0x8a, 0xe4,
-	0x3c, 0x33, 0x79, 0xb4, 0x99, 0x2f, 0xad, 0xdf, 0x23, 0x53, 0x6d, 0xcb, 0x6d, 0x66, 0xd8, 0x4d,
-	0x42, 0x40, 0x6b, 0xa5, 0xef, 0x45, 0x2a, 0x86, 0x55, 0xef, 0xaa, 0x77, 0x6d, 0xee, 0x7f, 0xff,
-	0xde, 0x7c, 0xc5, 0x9e, 0xcd, 0x5d, 0x4c, 0x6b, 0xaa, 0x18, 0xc2, 0x3a, 0x0c, 0x3f, 0xd9, 0x0a,
-	0x99, 0xd2, 0xc0, 0x8d, 0x92, 0xab, 0x95, 0xab, 0xde, 0xb5, 0x7a, 0x58, 0x44, 0xeb, 0xaf, 0x91,
-	0xc6, 0x2d, 0x18, 0xdc, 0xe5, 0x49, 0x06, 0x27, 0x5c, 0x68, 0x46, 0x89, 0x7f, 0x1f, 0x06, 0x8e,
-	0xbf, 0x1e, 0xe2, 0x27, 0x5b, 0x22, 0x93, 0xe7, 0xb8, 0x5c, 0x6c, 0xcc, 0x83, 0xf5, 0x35, 0x52,
-	0xdd, 0x49, 0xd4, 0xd9, 0x78, 0x15, 0x77, 0x34, 0x86, 0xab, 0xd7, 0x49, 0x6d, 0x3b, 0x8e, 0x35,
-	0x18, 0xc3, 0xe6, 0x48, 0x45, 0xf4, 0x0b, 0xbe, 0x8a, 0xe8, 0x33, 0x46, 0xaa, 0x7d, 0xa5, 0xad,
-	0x63, 0xf3, 0x43, 0xf7, 0xbd, 0xfe, 0xd0, 0x23, 0xb5, 0x43, 0xd3, 0xdd, 0xe1, 0x06, 0xd8, 0xeb,
-	0x64, 0x3a, 0x35, 0xdd, 0x7b, 0x76, 0xd0, 0x1f, 0x56, 0xb9, 0xf6, 0xca, 0x2a, 0x0f, 0x4d, 0xf7,
-	0x74, 0xd0, 0x87, 0xb0, 0x96, 0xe6, 0x1f, 0xa8, 0x24, 0x35, 0xdd, 0x56, 0x50, 0x30, 0xe7, 0x01,
-	0x5b, 0x23, 0x75, 0x2b, 0x52, 0x30, 0x96, 0xa7, 0xfd, 0x55, 0xff, 0xaa, 0x77, 0xad, 0x1a, 0x8e,
-	0x01, 0x76, 0x85, 0x4c, 0x1b, 0x95, 0xe9, 0x08, 0x5a, 0xc1, 0x6a, 0xd5, 0x6d, 0x1b, 0xc5, 0xeb,
-	0x37, 0x49, 0xfd, 0xd0, 0x74, 0x0f, 0x80, 0xc7, 0xa0, 0xd9, 0x7f, 0x48, 0xf5, 0x8c, 0x9b, 0x5c,
-	0xd1, 0xcc, 0x3f, 0x2b, 0xc2, 0x0a, 0x42, 0x97, 0xb9, 0xf1, 0x75, 0x95, 0xd4, 0x47, 0x9d, 0x60,
-	0x33, 0xa4, 0xd6, 0xce, 0xa2, 0x08, 0x8c, 0xa1, 0x13, 0x6c, 0x91, 0xcc, 0xdf, 0x91, 0x70, 0xd1,
-	0x87, 0xc8, 0x42, 0xec, 0x72, 0xa8, 0xc7, 0x16, 0xc8, 0x6c, 0x53, 0x49, 0x09, 0x91, 0xdd, 0xe3,
-	0x22, 0x81, 0x98, 0x56, 0xd8, 0x12, 0xa1, 0x27, 0xa0, 0x53, 0x61, 0x8c, 0x50, 0x32, 0x00, 0x29,
-	0x20, 0xa6, 0x3e, 0xbb, 0x44, 0x16, 0x9b, 0x2a, 0x49, 0x20, 0xb2, 0x42, 0xc9, 0x23, 0x65, 0x77,
-	0x2f, 0x84, 0xb1, 0x86, 0x56, 0x91, 0xb6, 0x95, 0x24, 0xd0, 0xe5, 0xc9, 0xb6, 0xee, 0x66, 0x29,
-	0x48, 0x4b, 0x27, 0x91, 0xa3, 0x00, 0x03, 0x91, 0x82, 0x44, 0x26, 0x5a, 0x2b, 0xa1, 0x2d, 0x19,
-	0xc3, 0x05, 0xfa, 0x47, 0xa7, 0xd9, 0x65, 0xb2, 0x5c, 0xa0, 0xa5, 0x03, 0x78, 0x0a, 0xb4, 0xce,
-	0xe6, 0xc9, 0x4c, 0xb1, 0x74, 0x7a, 0x7c, 0x72, 0x8b, 0x92, 0x12, 0x43, 0xa8, 0x1e, 0x84, 0x10,
-	0x29, 0x1d, 0xd3, 0x99, 0x92, 0x84, 0xbb, 0x10, 0x59, 0xa5, 0x5b, 0x01, 0x6d, 0xa0, 0xe0, 0x02,
-	0x6c, 0x03, 0xd7, 0x51, 0x2f, 0x04, 0x93, 0x25, 0x96, 0xce, 0x32, 0x4a, 0x1a, 0x7b, 0x22, 0x81,
-	0x23, 0x65, 0xf7, 0x54, 0x26, 0x63, 0x3a, 0xc7, 0xe6, 0x08, 0x39, 0x04, 0xcb, 0x0b, 0x07, 0xe6,
-	0xf1, 0xd8, 0x26, 0x8f, 0x7a, 0x50, 0x00, 0x94, 0xad, 0x10, 0xd6, 0xe4, 0x52, 0x2a, 0xdb, 0xd4,
-	0xc0, 0x2d, 0xec, 0xa9, 0x24, 0x06, 0x4d, 0x17, 0x50, 0xce, 0x4b, 0xb8, 0x48, 0x80, 0xb2, 0x71,
-	0x76, 0x00, 0x09, 0x8c, 0xb2, 0x17, 0xc7, 0xd9, 0x05, 0x8e, 0xd9, 0x4b, 0x28, 0x7e, 0x27, 0x13,
-	0x49, 0xec, 0x2c, 0xc9, 0xdb, 0xb2, 0x8c, 0x1a, 0x0b, 0xf1, 0x47, 0xb7, 0x5b, 0xed, 0x53, 0xba,
-	0xc2, 0x96, 0xc9, 0x42, 0x81, 0x1c, 0x82, 0xd5, 0x22, 0x72, 0xe6, 0x5d, 0x42, 0xa9, 0xc7, 0x99,
-	0x3d, 0xee, 0x1c, 0x42, 0xaa, 0xf4, 0x80, 0xae, 0x62, 0x43, 0x1d, 0xd3, 0xb0, 0x45, 0xf4, 0x32,
-	0x9e, 0xb0, 0x9b, 0xf6, 0xed, 0x60, 0x6c, 0x2f, 0xbd, 0xc2, 0x18, 0x99, 0x0d, 0x82, 0x10, 0xde,
-	0xcd, 0xc0, 0xd8, 0x90, 0x47, 0x40, 0x7f, 0xa9, 0x6d, 0xbc, 0x45, 0x88, 0xdb, 0x8b, 0x77, 0x1f,
-	0x18, 0x23, 0x73, 0xe3, 0xe8, 0x48, 0x49, 0xa0, 0x13, 0xac, 0x41, 0xa6, 0xef, 0x48, 0x61, 0x4c,
-	0x06, 0x31, 0xf5, 0xd0, 0xb7, 0x96, 0x3c, 0xd1, 0xaa, 0x8b, 0x57, 0x8e, 0x56, 0x70, 0x75, 0x4f,
-	0x48, 0x61, 0x7a, 0x6e, 0x62, 0x08, 0x99, 0x2a, 0x0c, 0xac, 0x6e, 0x74, 0x48, 0xa3, 0x0d, 0x5d,
-	0x1c, 0x8e, 0x9c, 0x7b, 0x89, 0xd0, 0x72, 0x3c, 0x66, 0x1f, 0xc9, 0xf6, 0x70, 0x78, 0xf7, 0xb5,
-	0x7a, 0x20, 0x64, 0x97, 0x56, 0x90, 0xac, 0x0d, 0x3c, 0x71, 0xc4, 0x33, 0xa4, 0xb6, 0x97, 0x64,
-	0xee, 0x94, 0xaa, 0x3b, 0x13, 0x03, 0x4c, 0x9b, 0xdc, 0x78, 0x34, 0xed, 0xae, 0xb4, 0xbb, 0x99,
-	0xb3, 0xa4, 0x7e, 0x47, 0xc6, 0xd0, 0x11, 0x12, 0x62, 0x3a, 0xe1, 0xdc, 0x77, 0x5d, 0x2a, 0xd9,
-	0x10, 0x63, 0x91, 0x81, 0x56, 0xfd, 0x12, 0x06, 0x68, 0xe1, 0x01, 0x37, 0x25, 0xa8, 0x83, 0x2d,
-	0x0d, 0xc0, 0x44, 0x5a, 0x9c, 0x95, 0xb7, 0x77, 0xd1, 0xda, 0x76, 0x4f, 0x3d, 0x18, 0x63, 0x86,
-	0xf6, 0xf0, 0xa4, 0x7d, 0xb0, 0xed, 0x81, 0xb1, 0x90, 0x36, 0x95, 0xec, 0x88, 0xae, 0xa1, 0x02,
-	0x4f, 0xba, 0xad, 0x78, 0x5c, 0xda, 0xfe, 0x0e, 0x36, 0x35, 0x84, 0x04, 0xb8, 0x29, 0xb3, 0xde,
-	0x77, 0xf3, 0xe7, 0xa4, 0x6e, 0x27, 0x82, 0x1b, 0x9a, 0x60, 0x29, 0xa8, 0x32, 0x0f, 0x53, 0xf4,
-	0x7d, 0x3b, 0xb1, 0xa0, 0xf3, 0x58, 0xb2, 0x25, 0x32, 0x9f, 0xe7, 0x9f, 0x70, 0x6d, 0x85, 0x23,
-	0xf9, 0xc6, 0x73, 0x1d, 0xd6, 0xaa, 0x3f, 0xc6, 0xbe, 0xc5, 0xeb, 0xde, 0x38, 0xe0, 0x66, 0x0c,
-	0x7d, 0xe7, 0xb1, 0x15, 0xb2, 0x30, 0x2c, 0x6d, 0x8c, 0x7f, 0xef, 0xb1, 0x45, 0x32, 0x87, 0xa5,
-	0x8d, 0x30, 0x43, 0x7f, 0x70, 0x20, 0x16, 0x51, 0x02, 0x7f, 0x74, 0x0c, 0x45, 0x15, 0x25, 0xfc,
-	0x27, 0x77, 0x18, 0x32, 0x14, 0x8d, 0x36, 0xf4, 0xb1, 0x87, 0x4a, 0x87, 0x87, 0x15, 0x30, 0x7d,
-	0xe2, 0x12, 0x91, 0x75, 0x94, 0xf8, 0xd4, 0x25, 0x16, 0x9c, 0x23, 0xf4, 0x99, 0x43, 0x0f, 0xb8,
-	0x8c, 0x55, 0xa7, 0x33, 0x42, 0x9f, 0x7b, 0x6c, 0x95, 0x2c, 0xe2, 0xf6, 0x1d, 0x9e, 0x70, 0x19,
-	0x8d, 0xf3, 0x5f, 0x78, 0x8c, 0x0e, 0x8d, 0x74, 0x83, 0x4c, 0x3f, 0xa8, 0x38, 0x53, 0x0a, 0x01,
-	0x39, 0xf6, 0x61, 0x85, 0xcd, 0xe5, 0xee, 0xe6, 0xf1, 0x47, 0x15, 0x36, 0x43, 0xa6, 0x5a, 0xd2,
-	0x80, 0xb6, 0xf4, 0x3d, 0x1c, 0xb6, 0xa9, 0xfc, 0xba, 0xd2, 0xf7, 0x71, 0xa4, 0x27, 0xdd, 0xb0,
-	0xd1, 0x87, 0x6e, 0x21, 0x7f, 0x58, 0xe8, 0xaf, 0xbe, 0x2b, 0xb5, 0xfc, 0xca, 0xfc, 0xe6, 0xe3,
-	0x49, 0xfb, 0x60, 0xc7, 0x37, 0x88, 0xfe, 0xee, 0xb3, 0x2b, 0x64, 0x79, 0x88, 0xb9, 0x3b, 0x3f,
-	0xba, 0x3b, 0x7f, 0xf8, 0x6c, 0x8d, 0x5c, 0xda, 0x07, 0x3b, 0x9e, 0x03, 0xdc, 0x24, 0x8c, 0x15,
-	0x91, 0xa1, 0x7f, 0xfa, 0xec, 0x5f, 0x64, 0x65, 0x1f, 0xec, 0xc8, 0xdf, 0xd2, 0xe2, 0x5f, 0x3e,
-	0x9b, 0x25, 0xd3, 0x21, 0x3e, 0x0a, 0x70, 0x0e, 0xf4, 0xb1, 0x8f, 0x4d, 0x1a, 0x86, 0x85, 0x9c,
-	0x27, 0x3e, 0x5a, 0xf7, 0x26, 0xb7, 0x51, 0x2f, 0x48, 0x9b, 0x3d, 0x2e, 0x25, 0x24, 0x86, 0x3e,
-	0xf5, 0xd9, 0x32, 0xa1, 0x21, 0xa4, 0xea, 0x1c, 0x4a, 0xf0, 0x33, 0x7c, 0xec, 0x99, 0x4b, 0x7e,
-	0x23, 0x03, 0x3d, 0x18, 0x2d, 0x3c, 0xf7, 0xd1, 0xea, 0x3c, 0xff, 0xe5, 0x95, 0x17, 0x3e, 0x5a,
-	0x5d, 0x38, 0xdf, 0x92, 0x1d, 0x45, 0x7f, 0xae, 0xa2, 0xaa, 0x53, 0x91, 0xc2, 0xa9, 0x88, 0xee,
-	0xd3, 0x8f, 0xeb, 0xa8, 0xca, 0x6d, 0x3a, 0x52, 0x31, 0xa0, 0x7c, 0x43, 0x3f, 0xa9, 0xa3, 0xf5,
-	0xd8, 0xba, 0xdc, 0xfa, 0x4f, 0x5d, 0x5c, 0xbc, 0x49, 0xad, 0x80, 0x7e, 0x86, 0x3f, 0x00, 0x52,
-	0xc4, 0xa7, 0xed, 0x63, 0xfa, 0xa8, 0x8e, 0x65, 0x6c, 0x27, 0x89, 0x8a, 0xb8, 0x1d, 0x0d, 0xd0,
-	0xe7, 0x75, 0x9c, 0xc0, 0xd2, 0x73, 0x52, 0x18, 0xf3, 0x45, 0x1d, 0xcb, 0x2b, 0x70, 0xd7, 0xb6,
-	0x00, 0x9f, 0x99, 0x2f, 0x1d, 0x6b, 0xc0, 0x2d, 0x47, 0x25, 0xa7, 0x96, 0x7e, 0x55, 0xdf, 0x58,
-	0x27, 0xb5, 0xc0, 0x24, 0xee, 0xd5, 0xa8, 0x11, 0x3f, 0x30, 0x09, 0x9d, 0xc0, 0x4b, 0xb6, 0xa3,
-	0x54, 0xb2, 0x7b, 0xd1, 0xd7, 0x77, 0xff, 0x4b, 0xbd, 0x9d, 0xff, 0xbf, 0x7d, 0xa3, 0x2b, 0x6c,
-	0x2f, 0x3b, 0xc3, 0x1f, 0xef, 0x56, 0xfe, 0x27, 0xbe, 0x2e, 0x54, 0xf1, 0xb5, 0x25, 0xa4, 0x05,
-	0x2d, 0x79, 0xb2, 0xe5, 0x7e, 0xce, 0x5b, 0xf9, 0xcf, 0xb9, 0x7f, 0x76, 0x36, 0xe5, 0xe2, 0x1b,
-	0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa4, 0x10, 0x52, 0xd9, 0x76, 0x09, 0x00, 0x00,
+	// 1334 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xd9, 0x72, 0x1b, 0x37,
+	0x16, 0x15, 0xd9, 0x94, 0x28, 0x42, 0x94, 0x04, 0x41, 0x8b, 0x65, 0x8f, 0x6a, 0xca, 0xa5, 0x27,
+	0x97, 0xaa, 0x2c, 0xcd, 0x8c, 0x6b, 0x66, 0x9e, 0xfc, 0x20, 0xb1, 0xb5, 0xb0, 0x6c, 0x2d, 0xd3,
+	0x94, 0x3d, 0xa9, 0x3c, 0xc4, 0x05, 0x75, 0x5f, 0x92, 0x88, 0xbb, 0x01, 0x06, 0x40, 0xcb, 0xe2,
+	0x5f, 0x24, 0xfe, 0x8e, 0x24, 0x95, 0xc5, 0x59, 0x2a, 0x5f, 0x90, 0xfd, 0x39, 0x9f, 0x90, 0x0f,
+	0xc8, 0xea, 0x35, 0x75, 0xd1, 0x4d, 0x76, 0xbb, 0xca, 0x79, 0xca, 0x5b, 0xdf, 0x83, 0x8b, 0x83,
+	0x73, 0xcf, 0xbd, 0x40, 0x93, 0x66, 0xa8, 0x92, 0x44, 0xc9, 0xcd, 0x81, 0x56, 0x56, 0xb1, 0xc5,
+	0x44, 0xc4, 0xe7, 0xa9, 0xc9, 0xa2, 0xcd, 0x6c, 0x69, 0xfd, 0x1e, 0x99, 0xea, 0x58, 0x6e, 0x53,
+	0xc3, 0x6e, 0x12, 0x02, 0x5a, 0x2b, 0x7d, 0x2f, 0x54, 0x11, 0xac, 0x56, 0xae, 0x56, 0xae, 0xcd,
+	0xfd, 0xeb, 0xef, 0x9b, 0xaf, 0xd8, 0xb3, 0xb9, 0x8b, 0x69, 0x2d, 0x15, 0x41, 0xd0, 0x80, 0xd1,
+	0x27, 0x5b, 0x21, 0x53, 0x1a, 0xb8, 0x51, 0x72, 0xb5, 0x7a, 0xb5, 0x72, 0xad, 0x11, 0xe4, 0xd1,
+	0xfa, 0x7f, 0x48, 0xf3, 0x16, 0x0c, 0xef, 0xf2, 0x38, 0x85, 0x13, 0x2e, 0x34, 0xa3, 0xc4, 0xbb,
+	0x0f, 0x43, 0xc7, 0xdf, 0x08, 0xf0, 0x93, 0x2d, 0x91, 0xc9, 0x73, 0x5c, 0xce, 0x37, 0x66, 0xc1,
+	0xfa, 0x1a, 0xa9, 0xed, 0xc4, 0xea, 0xac, 0x58, 0xc5, 0x1d, 0xcd, 0xd1, 0xea, 0x75, 0x52, 0xdf,
+	0x8e, 0x22, 0x0d, 0xc6, 0xb0, 0x39, 0x52, 0x15, 0x83, 0x9c, 0xaf, 0x2a, 0x06, 0x8c, 0x91, 0xda,
+	0x40, 0x69, 0xeb, 0xd8, 0xbc, 0xc0, 0x7d, 0xaf, 0x3f, 0xac, 0x90, 0xfa, 0xa1, 0xe9, 0xed, 0x70,
+	0x03, 0xec, 0xbf, 0x64, 0x3a, 0x31, 0xbd, 0x7b, 0x76, 0x38, 0x18, 0x55, 0xb9, 0xf6, 0xca, 0x2a,
+	0x0f, 0x4d, 0xef, 0x74, 0x38, 0x80, 0xa0, 0x9e, 0x64, 0x1f, 0xa8, 0x24, 0x31, 0xbd, 0xb6, 0x9f,
+	0x33, 0x67, 0x01, 0x5b, 0x23, 0x0d, 0x2b, 0x12, 0x30, 0x96, 0x27, 0x83, 0x55, 0xef, 0x6a, 0xe5,
+	0x5a, 0x2d, 0x28, 0x00, 0x76, 0x85, 0x4c, 0x1b, 0x95, 0xea, 0x10, 0xda, 0xfe, 0x6a, 0xcd, 0x6d,
+	0x1b, 0xc7, 0xeb, 0x37, 0x49, 0xe3, 0xd0, 0xf4, 0x0e, 0x80, 0x47, 0xa0, 0xd9, 0x3f, 0x48, 0xed,
+	0x8c, 0x9b, 0x4c, 0xd1, 0xcc, 0x9f, 0x2b, 0xc2, 0x0a, 0x02, 0x97, 0xb9, 0xfe, 0x06, 0x69, 0xfa,
+	0x87, 0xb7, 0xff, 0x02, 0x03, 0x4a, 0x37, 0x7d, 0xae, 0xa3, 0x23, 0x9e, 0x8c, 0xcc, 0x2f, 0x80,
+	0x8d, 0x2f, 0x6a, 0xa4, 0x31, 0xee, 0x34, 0x9b, 0x21, 0xf5, 0x4e, 0x1a, 0x86, 0x60, 0x0c, 0x9d,
+	0x60, 0x8b, 0x64, 0xfe, 0x8e, 0x84, 0x8b, 0x01, 0x84, 0x16, 0x22, 0x97, 0x43, 0x2b, 0x6c, 0x81,
+	0xcc, 0xb6, 0x94, 0x94, 0x10, 0xda, 0x3d, 0x2e, 0x62, 0x88, 0x68, 0x95, 0x2d, 0x11, 0x7a, 0x02,
+	0x3a, 0x11, 0xc6, 0x08, 0x25, 0x7d, 0x90, 0x02, 0x22, 0xea, 0xb1, 0x4b, 0x64, 0xb1, 0xa5, 0xe2,
+	0x18, 0x42, 0x2b, 0x94, 0x3c, 0x52, 0x76, 0xf7, 0x42, 0x18, 0x6b, 0x68, 0x0d, 0x69, 0xdb, 0x71,
+	0x0c, 0x3d, 0x1e, 0x6f, 0xeb, 0x5e, 0x9a, 0x80, 0xb4, 0x74, 0x12, 0x39, 0x72, 0xd0, 0x17, 0x09,
+	0x48, 0x64, 0xa2, 0xf5, 0x12, 0xda, 0x96, 0x11, 0x5c, 0x60, 0x7f, 0xe8, 0x34, 0xbb, 0x4c, 0x96,
+	0x73, 0xb4, 0x74, 0x00, 0x4f, 0x80, 0x36, 0xd8, 0x3c, 0x99, 0xc9, 0x97, 0x4e, 0x8f, 0x4f, 0x6e,
+	0x51, 0x52, 0x62, 0x08, 0xd4, 0x83, 0x00, 0x42, 0xa5, 0x23, 0x3a, 0x53, 0x92, 0x70, 0x17, 0x42,
+	0xab, 0x74, 0xdb, 0xa7, 0x4d, 0x14, 0x9c, 0x83, 0x1d, 0xe0, 0x3a, 0xec, 0x07, 0x60, 0xd2, 0xd8,
+	0xd2, 0x59, 0x46, 0x49, 0x73, 0x4f, 0xc4, 0x70, 0xa4, 0xec, 0x9e, 0x4a, 0x65, 0x44, 0xe7, 0xd8,
+	0x1c, 0x21, 0x87, 0x60, 0x79, 0xee, 0xc0, 0x3c, 0x1e, 0xdb, 0xe2, 0x61, 0x1f, 0x72, 0x80, 0xb2,
+	0x15, 0xc2, 0x5a, 0x5c, 0x4a, 0x65, 0x5b, 0x1a, 0xb8, 0x85, 0x3d, 0x15, 0x47, 0xa0, 0xe9, 0x02,
+	0xca, 0x79, 0x09, 0x17, 0x31, 0x50, 0x56, 0x64, 0xfb, 0x10, 0xc3, 0x38, 0x7b, 0xb1, 0xc8, 0xce,
+	0x71, 0xcc, 0x5e, 0x42, 0xf1, 0x3b, 0xa9, 0x88, 0x23, 0x67, 0x49, 0xd6, 0x96, 0x65, 0xd4, 0x98,
+	0x8b, 0x3f, 0xba, 0xdd, 0xee, 0x9c, 0xd2, 0x15, 0xb6, 0x4c, 0x16, 0x72, 0xe4, 0x10, 0xac, 0x16,
+	0xa1, 0x33, 0xef, 0x12, 0x4a, 0x3d, 0x4e, 0xed, 0x71, 0xf7, 0x10, 0x12, 0xa5, 0x87, 0x74, 0x15,
+	0x1b, 0xea, 0x98, 0x46, 0x2d, 0xa2, 0x97, 0xf1, 0x84, 0xdd, 0x64, 0x60, 0x87, 0x85, 0xbd, 0xf4,
+	0x0a, 0x63, 0x64, 0xd6, 0xf7, 0x03, 0x78, 0x2b, 0x05, 0x63, 0x03, 0x1e, 0x02, 0xfd, 0xb1, 0xbe,
+	0xf1, 0x1a, 0x21, 0x6e, 0x2f, 0xbe, 0x2d, 0xc0, 0x18, 0x99, 0x2b, 0xa2, 0x23, 0x25, 0x81, 0x4e,
+	0xb0, 0x26, 0x99, 0xbe, 0x23, 0x85, 0x31, 0x29, 0x44, 0xb4, 0x82, 0xbe, 0xb5, 0xe5, 0x89, 0x56,
+	0x3d, 0xbc, 0xd2, 0xb4, 0x8a, 0xab, 0x7b, 0x42, 0x0a, 0xd3, 0x77, 0x13, 0x43, 0xc8, 0x54, 0x6e,
+	0x60, 0x6d, 0xa3, 0x4b, 0x9a, 0x1d, 0xe8, 0xe1, 0x70, 0x64, 0xdc, 0x4b, 0x84, 0x96, 0xe3, 0x82,
+	0x7d, 0x2c, 0xbb, 0x82, 0xc3, 0xbb, 0xaf, 0xd5, 0x03, 0x21, 0x7b, 0xb4, 0x8a, 0x64, 0x1d, 0xe0,
+	0xb1, 0x23, 0x9e, 0x21, 0xf5, 0xbd, 0x38, 0x75, 0xa7, 0xd4, 0xdc, 0x99, 0x18, 0x60, 0xda, 0xe4,
+	0xc6, 0xa3, 0x69, 0xf7, 0x64, 0xb8, 0x9b, 0x3f, 0x4b, 0x1a, 0x77, 0x64, 0x04, 0x5d, 0x21, 0x21,
+	0xa2, 0x13, 0xce, 0x7d, 0xd7, 0xa5, 0x92, 0x0d, 0x11, 0x16, 0xe9, 0x6b, 0x35, 0x28, 0x61, 0x80,
+	0x16, 0x1e, 0x70, 0x53, 0x82, 0xba, 0xd8, 0x52, 0x1f, 0x4c, 0xa8, 0xc5, 0x59, 0x79, 0x7b, 0x0f,
+	0xad, 0xed, 0xf4, 0xd5, 0x83, 0x02, 0x33, 0xb4, 0x8f, 0x27, 0xed, 0x83, 0xed, 0x0c, 0x8d, 0x85,
+	0xa4, 0xa5, 0x64, 0x57, 0xf4, 0x0c, 0x15, 0x78, 0xd2, 0x6d, 0xc5, 0xa3, 0xd2, 0xf6, 0x37, 0xb1,
+	0xa9, 0x01, 0xc4, 0xc0, 0x4d, 0x99, 0xf5, 0xbe, 0x9b, 0x3f, 0x27, 0x75, 0x3b, 0x16, 0xdc, 0xd0,
+	0x18, 0x4b, 0x41, 0x95, 0x59, 0x98, 0xa0, 0xef, 0xdb, 0xb1, 0x05, 0x9d, 0xc5, 0x92, 0x2d, 0x91,
+	0xf9, 0x2c, 0xff, 0x84, 0x6b, 0x2b, 0x1c, 0xc9, 0x97, 0x15, 0xd7, 0x61, 0xad, 0x06, 0x05, 0xf6,
+	0x15, 0x5e, 0xf7, 0xe6, 0x01, 0x37, 0x05, 0xf4, 0x75, 0x85, 0xad, 0x90, 0x85, 0x51, 0x69, 0x05,
+	0xfe, 0x4d, 0x85, 0x2d, 0x92, 0x39, 0x2c, 0x6d, 0x8c, 0x19, 0xfa, 0xad, 0x03, 0xb1, 0x88, 0x12,
+	0xf8, 0x9d, 0x63, 0xc8, 0xab, 0x28, 0xe1, 0xdf, 0xbb, 0xc3, 0x90, 0x21, 0x6f, 0xb4, 0xa1, 0x8f,
+	0x2b, 0xa8, 0x74, 0x74, 0x58, 0x0e, 0xd3, 0x27, 0x2e, 0x11, 0x59, 0xc7, 0x89, 0x4f, 0x5d, 0x62,
+	0xce, 0x39, 0x46, 0x9f, 0x39, 0xf4, 0x80, 0xcb, 0x48, 0x75, 0xbb, 0x63, 0xf4, 0x79, 0x85, 0xad,
+	0x92, 0x45, 0xdc, 0xbe, 0xc3, 0x63, 0x2e, 0xc3, 0x22, 0xff, 0x45, 0x85, 0xd1, 0x91, 0x91, 0x6e,
+	0x90, 0xe9, 0xbb, 0x55, 0x67, 0x4a, 0x2e, 0x20, 0xc3, 0xde, 0xab, 0xb2, 0xb9, 0xcc, 0xdd, 0x2c,
+	0x7e, 0xbf, 0xca, 0x66, 0xc8, 0x54, 0x5b, 0x1a, 0xd0, 0x96, 0xbe, 0x8d, 0xc3, 0x36, 0x95, 0x5d,
+	0x57, 0xfa, 0x0e, 0x8e, 0xf4, 0xa4, 0x1b, 0x36, 0xfa, 0xd0, 0x2d, 0x64, 0x0f, 0x0b, 0xfd, 0xc9,
+	0x73, 0xa5, 0x96, 0x5f, 0x99, 0x9f, 0x3d, 0x3c, 0x69, 0x1f, 0x6c, 0x71, 0x83, 0xe8, 0x2f, 0x1e,
+	0xbb, 0x42, 0x96, 0x47, 0x98, 0xbb, 0xf3, 0xe3, 0xbb, 0xf3, 0xab, 0xc7, 0xd6, 0xc8, 0xa5, 0x7d,
+	0xb0, 0xc5, 0x1c, 0xe0, 0x26, 0x61, 0xac, 0x08, 0x0d, 0xfd, 0xcd, 0x63, 0x7f, 0x23, 0x2b, 0xfb,
+	0x60, 0xc7, 0xfe, 0x96, 0x16, 0x7f, 0xf7, 0xd8, 0x2c, 0x99, 0x0e, 0xf0, 0x51, 0x80, 0x73, 0xa0,
+	0x8f, 0x3d, 0x6c, 0xd2, 0x28, 0xcc, 0xe5, 0x3c, 0xf1, 0xd0, 0xba, 0xff, 0x73, 0x1b, 0xf6, 0xfd,
+	0xa4, 0xd5, 0xe7, 0x52, 0x42, 0x6c, 0xe8, 0x53, 0x8f, 0x2d, 0x13, 0x1a, 0x40, 0xa2, 0xce, 0xa1,
+	0x04, 0x3f, 0xc3, 0xc7, 0x9e, 0xb9, 0xe4, 0xff, 0xa5, 0xa0, 0x87, 0xe3, 0x85, 0xe7, 0x1e, 0x5a,
+	0x9d, 0xe5, 0xbf, 0xbc, 0xf2, 0xc2, 0x43, 0xab, 0x73, 0xe7, 0xdb, 0xb2, 0xab, 0xe8, 0x0f, 0x35,
+	0x54, 0x75, 0x2a, 0x12, 0x38, 0x15, 0xe1, 0x7d, 0xfa, 0x41, 0x03, 0x55, 0xb9, 0x4d, 0x47, 0x2a,
+	0x02, 0x94, 0x6f, 0xe8, 0x87, 0x0d, 0xb4, 0x1e, 0x5b, 0x97, 0x59, 0xff, 0x91, 0x8b, 0xf3, 0x37,
+	0xa9, 0xed, 0xd3, 0x8f, 0xf1, 0x07, 0x40, 0xf2, 0xf8, 0xb4, 0x73, 0x4c, 0x1f, 0x35, 0xb0, 0x8c,
+	0xed, 0x38, 0x56, 0x21, 0xb7, 0xe3, 0x01, 0xfa, 0xa4, 0x81, 0x13, 0x58, 0x7a, 0x4e, 0x72, 0x63,
+	0x3e, 0x6d, 0x60, 0x79, 0x39, 0xee, 0xda, 0xe6, 0xe3, 0x33, 0xf3, 0x99, 0x63, 0xf5, 0xb9, 0xe5,
+	0xa8, 0xe4, 0xd4, 0xd2, 0xcf, 0x1b, 0x1b, 0xeb, 0xa4, 0xee, 0x9b, 0xd8, 0xbd, 0x1a, 0x75, 0xe2,
+	0xf9, 0x26, 0xa6, 0x13, 0x78, 0xc9, 0x76, 0x94, 0x8a, 0x77, 0x2f, 0x06, 0xfa, 0xee, 0x3f, 0x69,
+	0x65, 0xe7, 0xdf, 0xaf, 0xdf, 0xe8, 0x09, 0xdb, 0x4f, 0xcf, 0xf0, 0xb7, 0xbc, 0x95, 0xfd, 0xa7,
+	0xaf, 0x0b, 0x95, 0x7f, 0x6d, 0x09, 0x69, 0x41, 0x4b, 0x1e, 0x6f, 0xb9, 0x5f, 0xf7, 0x56, 0xf6,
+	0xeb, 0x1e, 0x9c, 0x9d, 0x4d, 0xb9, 0xf8, 0xc6, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x36,
+	0xfe, 0x7f, 0xd6, 0x09, 0x00, 0x00,
 }

internal/proto/internal.proto

@@ -127,14 +127,14 @@ message CreateIndexRequest {
 
 message InsertRequest {
   common.MsgBase base = 1;
-  string db_name = 2;
-  string collection_name = 3;
-  string partition_name = 4;
-  int64 dbID = 5;
-  int64 collectionID = 6;
-  int64 partitionID = 7;
-  int64 segmentID = 8;
-  string channelID = 9;
+  string shardName = 2;
+  string db_name = 3;
+  string collection_name = 4;
+  string partition_name = 5;
+  int64 dbID = 6;
+  int64 collectionID = 7;
+  int64 partitionID = 8;
+  int64 segmentID = 9;
   repeated uint64 timestamps = 10;
   repeated int64 rowIDs = 11;
   repeated common.Blob row_data = 12;
@@ -197,13 +197,13 @@ message RetrieveResults {
 
 message DeleteRequest {
   common.MsgBase base = 1;
-  string db_name = 2;
-  string collection_name = 3;
-  string partition_name = 4;
-  int64 dbID = 5;
-  int64 collectionID = 6;
-  int64 partitionID = 7;
-  string channelID = 8;
+  string shardName = 2;
+  string db_name = 3;
+  string collection_name = 4;
+  string partition_name = 5;
+  int64 dbID = 6;
+  int64 collectionID = 7;
+  int64 partitionID = 8;
   bytes expr_plan = 9;
   uint64 timestamp = 10;
 }

internal/proxy/task.go

@@ -923,7 +923,7 @@ func (it *insertTask) _assignSegmentID(stream msgstream.MsgStream, pack *msgstre
 		size += int(unsafe.Sizeof(msg.CollectionID))
 		size += int(unsafe.Sizeof(msg.PartitionID))
 		size += int(unsafe.Sizeof(msg.SegmentID))
-		size += int(unsafe.Sizeof(msg.ChannelID))
+		size += int(unsafe.Sizeof(msg.ShardName))
 		size += int(unsafe.Sizeof(msg.Timestamps))
 		size += int(unsafe.Sizeof(msg.RowIDs))
 		return size
@@ -962,8 +962,7 @@ func (it *insertTask) _assignSegmentID(stream msgstream.MsgStream, pack *msgstre
 					CollectionName: collectionName,
 					PartitionName:  partitionName,
 					SegmentID:      segmentID,
-					// todo rename to ChannelName
-					ChannelID: channelNames[key],
+					ShardName:      channelNames[key],
 				}
 				insertMsg := &msgstream.InsertMsg{
 					BaseMsg: msgstream.BaseMsg{

internal/querynode/data_sync_service_test.go

@@ -71,7 +71,7 @@ func TestDataSyncService_Start(t *testing.T) {
 				CollectionID: collectionID,
 				PartitionID:  defaultPartitionID,
 				SegmentID:    UniqueID(0),
-				ChannelID:    "0",
+				ShardName:    "0",
 				Timestamps:   []Timestamp{Timestamp(i + 1000), Timestamp(i + 1000)},
 				RowIDs:       []int64{int64(i), int64(i)},
 				RowData: []*commonpb.Blob{

internal/querynode/flow_graph_insert_node.go

@@ -84,7 +84,7 @@ func (iNode *insertNode) Operate(in []flowgraph.Msg) []flowgraph.Msg {
 
 		// check if segment exists, if not, create this segment
 		if !iNode.replica.hasSegment(task.SegmentID) {
-			err := iNode.replica.addSegment(task.SegmentID, task.PartitionID, task.CollectionID, task.ChannelID, segmentTypeGrowing, true)
+			err := iNode.replica.addSegment(task.SegmentID, task.PartitionID, task.CollectionID, task.ShardName, segmentTypeGrowing, true)
 			if err != nil {
 				log.Warn(err.Error())
 				continue

internal/querynode/load_service_test.go

@@ -885,7 +885,7 @@ func doInsert(ctx context.Context, collectionID UniqueID, partitionID UniqueID,
 				CollectionID: collectionID,
 				PartitionID:  partitionID,
 				SegmentID:    segmentID,
-				ChannelID:    "0",
+				ShardName:    "0",
 				Timestamps:   []uint64{uint64(i + 1000)},
 				RowIDs:       []int64{int64(i)},
 				RowData: []*commonpb.Blob{

internal/querynode/mock_test.go

@@ -705,7 +705,7 @@ func genSimpleInsertMsg() (*msgstream.InsertMsg, error) {
 			CollectionID:   defaultCollectionID,
 			PartitionID:    defaultPartitionID,
 			SegmentID:      defaultSegmentID,
-			ChannelID:      defaultVChannel,
+			ShardName:      defaultVChannel,
 			Timestamps:     genSimpleTimestampFieldData(),
 			RowIDs:         genSimpleRowIDField(),
 			RowData:        rowData,

internal/util/typeutil/conversion_test.go

@@ -73,4 +73,5 @@ func TestConversion(t *testing.T) {
 		ret1 := SliceRemoveDuplicate(arr)
 		assert.Equal(t, 3, len(ret1))
 	})
+
 }