Must create index before load (#19516)

Signed-off-by: Ncai.zhang <cai.zhang@zilliz.com>
Signed-off-by: Ncai.zhang <cai.zhang@zilliz.com>

internal/proto/query_coord.proto

@@ -96,6 +96,8 @@ message LoadCollectionRequest {
   int64 collectionID = 3;
   schema.CollectionSchema schema = 4;
   int32 replica_number = 5;
+  // fieldID -> indexID
+  map<int64, int64> field_indexID = 6;
 }
 
 message ReleaseCollectionRequest {
@@ -120,6 +122,8 @@ message LoadPartitionsRequest {
   repeated int64 partitionIDs = 4;
   schema.CollectionSchema schema = 5;
   int32 replica_number = 6;
+  // fieldID -> indexID
+  map<int64, int64> field_indexID = 7;
 }
 
 message ReleasePartitionsRequest {

internal/proto/querypb/query_coord.pb.go

@@ -454,14 +454,16 @@ func (m *ShowPartitionsResponse) GetInMemoryPercentages() []int64 {
 }
 
 type LoadCollectionRequest struct {
-	Base                 *commonpb.MsgBase          `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
-	DbID                 int64                      `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
-	CollectionID         int64                      `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
-	Schema               *schemapb.CollectionSchema `protobuf:"bytes,4,opt,name=schema,proto3" json:"schema,omitempty"`
-	ReplicaNumber        int32                      `protobuf:"varint,5,opt,name=replica_number,json=replicaNumber,proto3" json:"replica_number,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
-	XXX_unrecognized     []byte                     `json:"-"`
-	XXX_sizecache        int32                      `json:"-"`
+	Base          *commonpb.MsgBase          `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	DbID          int64                      `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
+	CollectionID  int64                      `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
+	Schema        *schemapb.CollectionSchema `protobuf:"bytes,4,opt,name=schema,proto3" json:"schema,omitempty"`
+	ReplicaNumber int32                      `protobuf:"varint,5,opt,name=replica_number,json=replicaNumber,proto3" json:"replica_number,omitempty"`
+	// fieldID -> indexID
+	FieldIndexID         map[int64]int64 `protobuf:"bytes,6,rep,name=field_indexID,json=fieldIndexID,proto3" json:"field_indexID,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
 }
 
 func (m *LoadCollectionRequest) Reset()         { *m = LoadCollectionRequest{} }
@@ -524,6 +526,13 @@ func (m *LoadCollectionRequest) GetReplicaNumber() int32 {
 	return 0
 }
 
+func (m *LoadCollectionRequest) GetFieldIndexID() map[int64]int64 {
+	if m != nil {
+		return m.FieldIndexID
+	}
+	return nil
+}
+
 type ReleaseCollectionRequest struct {
 	Base                 *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
 	DbID                 int64             `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
@@ -659,15 +668,17 @@ func (m *GetStatisticsRequest) GetScope() DataScope {
 }
 
 type LoadPartitionsRequest struct {
-	Base                 *commonpb.MsgBase          `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
-	DbID                 int64                      `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
-	CollectionID         int64                      `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
-	PartitionIDs         []int64                    `protobuf:"varint,4,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
-	Schema               *schemapb.CollectionSchema `protobuf:"bytes,5,opt,name=schema,proto3" json:"schema,omitempty"`
-	ReplicaNumber        int32                      `protobuf:"varint,6,opt,name=replica_number,json=replicaNumber,proto3" json:"replica_number,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
-	XXX_unrecognized     []byte                     `json:"-"`
-	XXX_sizecache        int32                      `json:"-"`
+	Base          *commonpb.MsgBase          `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	DbID          int64                      `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
+	CollectionID  int64                      `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
+	PartitionIDs  []int64                    `protobuf:"varint,4,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
+	Schema        *schemapb.CollectionSchema `protobuf:"bytes,5,opt,name=schema,proto3" json:"schema,omitempty"`
+	ReplicaNumber int32                      `protobuf:"varint,6,opt,name=replica_number,json=replicaNumber,proto3" json:"replica_number,omitempty"`
+	// fieldID -> indexID
+	FieldIndexID         map[int64]int64 `protobuf:"bytes,7,rep,name=field_indexID,json=fieldIndexID,proto3" json:"field_indexID,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
 }
 
 func (m *LoadPartitionsRequest) Reset()         { *m = LoadPartitionsRequest{} }
@@ -737,6 +748,13 @@ func (m *LoadPartitionsRequest) GetReplicaNumber() int32 {
 	return 0
 }
 
+func (m *LoadPartitionsRequest) GetFieldIndexID() map[int64]int64 {
+	if m != nil {
+		return m.FieldIndexID
+	}
+	return nil
+}
+
 type ReleasePartitionsRequest struct {
 	Base                 *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
 	DbID                 int64             `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
@@ -3611,9 +3629,11 @@ func init() {
 	proto.RegisterType((*ShowPartitionsRequest)(nil), "milvus.proto.query.ShowPartitionsRequest")
 	proto.RegisterType((*ShowPartitionsResponse)(nil), "milvus.proto.query.ShowPartitionsResponse")
 	proto.RegisterType((*LoadCollectionRequest)(nil), "milvus.proto.query.LoadCollectionRequest")
+	proto.RegisterMapType((map[int64]int64)(nil), "milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry")
 	proto.RegisterType((*ReleaseCollectionRequest)(nil), "milvus.proto.query.ReleaseCollectionRequest")
 	proto.RegisterType((*GetStatisticsRequest)(nil), "milvus.proto.query.GetStatisticsRequest")
 	proto.RegisterType((*LoadPartitionsRequest)(nil), "milvus.proto.query.LoadPartitionsRequest")
+	proto.RegisterMapType((map[int64]int64)(nil), "milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry")
 	proto.RegisterType((*ReleasePartitionsRequest)(nil), "milvus.proto.query.ReleasePartitionsRequest")
 	proto.RegisterType((*GetPartitionStatesRequest)(nil), "milvus.proto.query.GetPartitionStatesRequest")
 	proto.RegisterType((*GetPartitionStatesResponse)(nil), "milvus.proto.query.GetPartitionStatesResponse")
@@ -3662,229 +3682,233 @@ func init() {
 func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
 
 var fileDescriptor_aab7cc9a69ed26e8 = []byte{
-	// 3549 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3b, 0x49, 0x6f, 0x1c, 0xd7,
-	0x99, 0xac, 0x5e, 0xc8, 0xee, 0xaf, 0x17, 0x16, 0x1f, 0x25, 0xaa, 0xdd, 0xd6, 0xe6, 0xd2, 0x62,
-	0x0e, 0x65, 0x93, 0x32, 0x65, 0x1b, 0xf2, 0x8c, 0x8d, 0x19, 0x89, 0xb4, 0x68, 0x8e, 0x24, 0x9a,
-	0x53, 0x2d, 0x69, 0x06, 0x82, 0x31, 0x3d, 0xd5, 0x5d, 0x8f, 0xcd, 0x82, 0xaa, 0xab, 0x5a, 0x55,
-	0xd5, 0x94, 0xe8, 0xb9, 0xce, 0x65, 0xb2, 0x01, 0xc9, 0x21, 0x40, 0x80, 0x20, 0xa7, 0x04, 0x48,
-	0x02, 0x1b, 0xc8, 0x21, 0x01, 0x72, 0x08, 0x82, 0x00, 0x39, 0x24, 0xa7, 0x20, 0x3f, 0x20, 0x40,
-	0x8e, 0x39, 0x24, 0x40, 0x4e, 0x39, 0xe4, 0x16, 0xbc, 0xad, 0xd6, 0x57, 0x64, 0x8b, 0x94, 0xb7,
-	0x20, 0xb7, 0xae, 0xef, 0x2d, 0xdf, 0xf7, 0xbe, 0xfd, 0xfb, 0xde, 0x6b, 0x98, 0x7b, 0x3c, 0xc6,
-	0xde, 0x7e, 0xb7, 0xef, 0xba, 0x9e, 0xb9, 0x3c, 0xf2, 0xdc, 0xc0, 0x45, 0x68, 0x68, 0xd9, 0x7b,
-	0x63, 0x9f, 0x7d, 0x2d, 0xd3, 0xf1, 0x76, 0xbd, 0xef, 0x0e, 0x87, 0xae, 0xc3, 0x60, 0xed, 0x7a,
-	0x7c, 0x46, 0xbb, 0x69, 0x39, 0x01, 0xf6, 0x1c, 0xc3, 0x16, 0xa3, 0x7e, 0x7f, 0x17, 0x0f, 0x0d,
-	0xfe, 0xa5, 0x9a, 0x46, 0x60, 0xc4, 0xf7, 0xd7, 0xfe, 0x4f, 0x81, 0x85, 0xce, 0xae, 0xfb, 0x64,
-	0xcd, 0xb5, 0x6d, 0xdc, 0x0f, 0x2c, 0xd7, 0xf1, 0x75, 0xfc, 0x78, 0x8c, 0xfd, 0x00, 0x5d, 0x85,
-	0x52, 0xcf, 0xf0, 0x71, 0x4b, 0x39, 0xaf, 0x2c, 0xd6, 0x56, 0x4f, 0x2f, 0x27, 0x28, 0xe1, 0x24,
-	0xdc, 0xf5, 0x07, 0x37, 0x0d, 0x1f, 0xeb, 0x74, 0x26, 0x42, 0x50, 0x32, 0x7b, 0x9b, 0xeb, 0xad,
-	0xc2, 0x79, 0x65, 0xb1, 0xa8, 0xd3, 0xdf, 0xe8, 0x22, 0x34, 0xfa, 0xe1, 0xde, 0x9b, 0xeb, 0x7e,
-	0xab, 0x78, 0xbe, 0xb8, 0x58, 0xd4, 0x93, 0x40, 0xed, 0xf7, 0x0a, 0x9c, 0xca, 0x90, 0xe1, 0x8f,
-	0x5c, 0xc7, 0xc7, 0xe8, 0x1a, 0x4c, 0xfb, 0x81, 0x11, 0x8c, 0x7d, 0x4e, 0xc9, 0x8b, 0x52, 0x4a,
-	0x3a, 0x74, 0x8a, 0xce, 0xa7, 0x66, 0xd1, 0x16, 0x24, 0x68, 0xd1, 0x6b, 0x70, 0xc2, 0x72, 0xee,
-	0xe2, 0xa1, 0xeb, 0xed, 0x77, 0x47, 0xd8, 0xeb, 0x63, 0x27, 0x30, 0x06, 0x58, 0xd0, 0x38, 0x2f,
-	0xc6, 0xb6, 0xa3, 0x21, 0xf4, 0x26, 0x9c, 0x62, 0x52, 0xf2, 0xb1, 0xb7, 0x67, 0xf5, 0x71, 0xd7,
-	0xd8, 0x33, 0x2c, 0xdb, 0xe8, 0xd9, 0xb8, 0x55, 0x3a, 0x5f, 0x5c, 0xac, 0xe8, 0x27, 0xe9, 0x70,
-	0x87, 0x8d, 0xde, 0x10, 0x83, 0xda, 0xf7, 0x14, 0x38, 0x49, 0x4e, 0xb8, 0x6d, 0x78, 0x81, 0xf5,
-	0x09, 0xf0, 0x59, 0x83, 0x7a, 0xfc, 0x6c, 0xad, 0x22, 0x1d, 0x4b, 0xc0, 0xc8, 0x9c, 0x91, 0x40,
-	0x4f, 0x78, 0x52, 0xa2, 0xc7, 0x4c, 0xc0, 0xb4, 0xef, 0x72, 0x85, 0x88, 0xd3, 0x79, 0x1c, 0x41,
-	0xa4, 0x71, 0x16, 0xb2, 0x38, 0x8f, 0x20, 0x06, 0xed, 0x0f, 0x0a, 0x9c, 0xbc, 0xe3, 0x1a, 0x66,
-	0xa4, 0x30, 0x9f, 0x3e, 0x3b, 0xdf, 0x81, 0x69, 0x66, 0x5d, 0xad, 0x12, 0xc5, 0x75, 0x29, 0x89,
-	0x8b, 0x5b, 0x5e, 0x44, 0x61, 0x87, 0x02, 0x74, 0xbe, 0x08, 0x5d, 0x82, 0xa6, 0x87, 0x47, 0xb6,
-	0xd5, 0x37, 0xba, 0xce, 0x78, 0xd8, 0xc3, 0x5e, 0xab, 0x7c, 0x5e, 0x59, 0x2c, 0xeb, 0x0d, 0x0e,
-	0xdd, 0xa2, 0x40, 0xed, 0xdb, 0x0a, 0xb4, 0x74, 0x6c, 0x63, 0xc3, 0xc7, 0x9f, 0xe5, 0x61, 0x17,
-	0x60, 0xda, 0x71, 0x4d, 0xbc, 0xb9, 0x4e, 0x0f, 0x5b, 0xd4, 0xf9, 0x97, 0xf6, 0x57, 0x05, 0x4e,
-	0x6c, 0xe0, 0x80, 0x48, 0xdd, 0xf2, 0x03, 0xab, 0x1f, 0xaa, 0xf5, 0x3b, 0x50, 0xf4, 0xf0, 0x63,
-	0x4e, 0xd9, 0x95, 0x24, 0x65, 0xa1, 0x93, 0x92, 0xad, 0xd4, 0xc9, 0x3a, 0xf4, 0x12, 0xd4, 0xcd,
-	0xa1, 0xdd, 0xed, 0xef, 0x1a, 0x8e, 0x83, 0x6d, 0xa6, 0x37, 0x55, 0xbd, 0x66, 0x0e, 0xed, 0x35,
-	0x0e, 0x42, 0x67, 0x01, 0x7c, 0x3c, 0x18, 0x62, 0x27, 0x88, 0xfc, 0x4a, 0x0c, 0x82, 0x96, 0x60,
-	0x6e, 0xc7, 0x73, 0x87, 0x5d, 0x7f, 0xd7, 0xf0, 0xcc, 0xae, 0x8d, 0x0d, 0x13, 0x7b, 0x94, 0xfa,
-	0x8a, 0x3e, 0x4b, 0x06, 0x3a, 0x04, 0x7e, 0x87, 0x82, 0xd1, 0x35, 0x28, 0xfb, 0x7d, 0x77, 0x84,
-	0xa9, 0x0c, 0x9a, 0xab, 0x67, 0x96, 0xb3, 0x7e, 0x77, 0x79, 0xdd, 0x08, 0x8c, 0x0e, 0x99, 0xa4,
-	0xb3, 0xb9, 0xda, 0x97, 0x0b, 0x4c, 0x09, 0x3f, 0xe7, 0x36, 0x1d, 0x53, 0xd4, 0xf2, 0xf3, 0x51,
-	0xd4, 0x69, 0x99, 0xa2, 0xfe, 0x22, 0x52, 0xd4, 0xcf, 0x3b, 0x43, 0x22, 0x65, 0x2e, 0x27, 0x94,
-	0xf9, 0x07, 0x0a, 0xbc, 0xb0, 0x81, 0x83, 0x90, 0x7c, 0xa2, 0x9b, 0xf8, 0x73, 0xea, 0xa8, 0x3f,
-	0x56, 0xa0, 0x2d, 0xa3, 0xf5, 0x38, 0xce, 0xfa, 0x21, 0x2c, 0x84, 0x38, 0xba, 0x26, 0xf6, 0xfb,
-	0x9e, 0x35, 0xa2, 0x62, 0xa4, 0xe6, 0x57, 0x5b, 0xbd, 0x20, 0x33, 0x8b, 0x34, 0x05, 0x27, 0xc3,
-	0x2d, 0xd6, 0x63, 0x3b, 0x68, 0x5f, 0x55, 0xe0, 0x24, 0x31, 0x77, 0x6e, 0x9f, 0xce, 0x8e, 0x7b,
-	0x74, 0xbe, 0x26, 0x2d, 0xbf, 0x90, 0xb1, 0xfc, 0x09, 0x78, 0x4c, 0x33, 0x9f, 0x34, 0x3d, 0xc7,
-	0xe1, 0xdd, 0x1b, 0x50, 0xb6, 0x9c, 0x1d, 0x57, 0xb0, 0xea, 0x9c, 0x8c, 0x55, 0x71, 0x64, 0x6c,
-	0xb6, 0xe6, 0x30, 0x2a, 0x22, 0x57, 0x74, 0x0c, 0x75, 0x4b, 0x1f, 0xbb, 0x20, 0x39, 0xf6, 0x57,
-	0x14, 0x38, 0x95, 0x41, 0x78, 0x9c, 0x73, 0xbf, 0x0d, 0xd3, 0xd4, 0xc1, 0x8a, 0x83, 0x5f, 0x94,
-	0x1e, 0x3c, 0x86, 0xee, 0x8e, 0xe5, 0x07, 0x3a, 0x5f, 0xa3, 0xb9, 0xa0, 0xa6, 0xc7, 0x88, 0xeb,
-	0xe7, 0x6e, 0xbf, 0xeb, 0x18, 0x43, 0xc6, 0x80, 0xaa, 0x5e, 0xe3, 0xb0, 0x2d, 0x63, 0x88, 0xd1,
-	0x0b, 0x50, 0x21, 0x26, 0xdb, 0xb5, 0x4c, 0x21, 0xfe, 0x19, 0x6a, 0xc2, 0xa6, 0x8f, 0xce, 0x00,
-	0xd0, 0x21, 0xc3, 0x34, 0x3d, 0x16, 0x15, 0xaa, 0x7a, 0x95, 0x40, 0x6e, 0x10, 0x80, 0xf6, 0x75,
-	0x05, 0xea, 0xc4, 0x67, 0xdf, 0xc5, 0x81, 0x41, 0xe4, 0x80, 0xde, 0x82, 0xaa, 0xed, 0x1a, 0x66,
-	0x37, 0xd8, 0x1f, 0x31, 0x54, 0xcd, 0x34, 0xaf, 0xd9, 0x11, 0xc8, 0xa2, 0x7b, 0xfb, 0x23, 0xac,
-	0x57, 0x6c, 0xfe, 0x6b, 0x12, 0x7e, 0x67, 0x4c, 0xb9, 0x28, 0x31, 0xe5, 0x8f, 0xca, 0xb0, 0xf0,
-	0x9f, 0x46, 0xd0, 0xdf, 0x5d, 0x1f, 0x8a, 0xe0, 0x76, 0x74, 0x25, 0x88, 0x7c, 0x5b, 0x21, 0xee,
-	0xdb, 0x9e, 0x9b, 0xef, 0x0c, 0xf5, 0xbc, 0x2c, 0xd3, 0x73, 0x52, 0x60, 0x2c, 0x3f, 0xe0, 0xa2,
-	0x8a, 0xe9, 0x79, 0x2c, 0x06, 0x4d, 0x1f, 0x25, 0x06, 0xad, 0x41, 0x03, 0x3f, 0xed, 0xdb, 0x63,
-	0x22, 0x73, 0x8a, 0x7d, 0x86, 0x62, 0x3f, 0x2b, 0xc1, 0x1e, 0x37, 0xb2, 0x3a, 0x5f, 0xb4, 0xc9,
-	0x69, 0x60, 0xa2, 0x1e, 0xe2, 0xc0, 0x68, 0x55, 0x28, 0x19, 0xe7, 0xf3, 0x44, 0x2d, 0xf4, 0x83,
-	0x89, 0x9b, 0x7c, 0xa1, 0xd3, 0x50, 0xe5, 0x11, 0x6f, 0x73, 0xbd, 0x55, 0xa5, 0xec, 0x8b, 0x00,
-	0xc8, 0x80, 0x06, 0xf7, 0x40, 0x9c, 0x42, 0xa0, 0x14, 0xbe, 0x2d, 0x43, 0x20, 0x17, 0x76, 0x9c,
-	0x72, 0xff, 0x5d, 0x27, 0xf0, 0xf6, 0xf5, 0xba, 0x1f, 0x03, 0x91, 0xa2, 0xc6, 0xdd, 0xd9, 0xb1,
-	0x2d, 0x07, 0x6f, 0x31, 0x09, 0xd7, 0x28, 0x11, 0x49, 0x60, 0xbb, 0x0b, 0x73, 0x99, 0x8d, 0x90,
-	0x0a, 0xc5, 0x47, 0x78, 0x9f, 0xaa, 0x51, 0x51, 0x27, 0x3f, 0xd1, 0xeb, 0x50, 0xde, 0x33, 0xec,
-	0x31, 0xa6, 0x6a, 0x72, 0x38, 0x27, 0xd9, 0xe4, 0x7f, 0x2e, 0x5c, 0x57, 0xb4, 0xef, 0x2b, 0x70,
-	0xf2, 0xbe, 0xe3, 0x8f, 0x7b, 0xe1, 0x09, 0x3e, 0x1b, 0x6d, 0x4d, 0xfb, 0x89, 0x52, 0xc6, 0x4f,
-	0x68, 0x3f, 0x2f, 0xc1, 0x2c, 0x3f, 0x05, 0x11, 0x2a, 0x35, 0xf8, 0xd3, 0x50, 0x0d, 0x43, 0x05,
-	0x67, 0x48, 0x04, 0x40, 0xe7, 0xa1, 0x16, 0x53, 0x77, 0x4e, 0x55, 0x1c, 0x34, 0x11, 0x69, 0x22,
-	0xf0, 0x97, 0x62, 0x81, 0xff, 0x0c, 0xc0, 0x8e, 0x3d, 0xf6, 0x77, 0xbb, 0x81, 0x35, 0xc4, 0x3c,
-	0xf1, 0xa8, 0x52, 0xc8, 0x3d, 0x6b, 0x88, 0xd1, 0x0d, 0xa8, 0xf7, 0x2c, 0xc7, 0x76, 0x07, 0xdd,
-	0x91, 0x11, 0xec, 0xfa, 0xad, 0xe9, 0x5c, 0x05, 0xbf, 0x65, 0x61, 0xdb, 0xbc, 0x49, 0xe7, 0xea,
-	0x35, 0xb6, 0x66, 0x9b, 0x2c, 0x41, 0x67, 0xa1, 0xe6, 0x8c, 0x87, 0x5d, 0x77, 0xa7, 0xeb, 0xb9,
-	0x4f, 0x88, 0x89, 0x50, 0x14, 0xce, 0x78, 0xf8, 0xfe, 0x8e, 0xee, 0x3e, 0x21, 0xae, 0xba, 0x4a,
-	0x9c, 0xb6, 0x6f, 0xbb, 0x03, 0xbf, 0x55, 0x99, 0x68, 0xff, 0x68, 0x01, 0x59, 0x6d, 0x62, 0x3b,
-	0x30, 0xe8, 0xea, 0xea, 0x64, 0xab, 0xc3, 0x05, 0xe8, 0x32, 0x34, 0xfb, 0xee, 0x70, 0x64, 0x50,
-	0x0e, 0xdd, 0xf2, 0xdc, 0x21, 0xb5, 0x8f, 0xa2, 0x9e, 0x82, 0xa2, 0x35, 0xa8, 0x59, 0x8e, 0x89,
-	0x9f, 0x72, 0x23, 0xaa, 0x51, 0x3c, 0x9a, 0xcc, 0x88, 0x28, 0xa2, 0x4d, 0x32, 0x97, 0x2a, 0x28,
-	0x58, 0xe2, 0xa7, 0x4f, 0x34, 0x43, 0xd8, 0xa2, 0x6f, 0x7d, 0x88, 0x5b, 0x75, 0x26, 0x45, 0x0e,
-	0xeb, 0x58, 0x1f, 0x62, 0x92, 0xd4, 0x5a, 0x8e, 0x8f, 0xbd, 0x40, 0x94, 0x18, 0xad, 0x06, 0x55,
-	0x9f, 0x06, 0x83, 0x72, 0xc5, 0xd6, 0xfe, 0x5c, 0x80, 0x66, 0x12, 0x11, 0x6a, 0xc1, 0xcc, 0x0e,
-	0x85, 0x08, 0xed, 0x11, 0x9f, 0x04, 0x2d, 0x76, 0x48, 0xb5, 0xdf, 0xa5, 0xb4, 0x50, 0xe5, 0xa9,
-	0xe8, 0x35, 0x06, 0xa3, 0x1b, 0x10, 0x25, 0x60, 0xc7, 0xa3, 0x1a, 0x5b, 0xa4, 0x28, 0xab, 0x14,
-	0x42, 0xe3, 0x5a, 0x0b, 0x66, 0xd8, 0x31, 0x84, 0xea, 0x88, 0x4f, 0x32, 0xd2, 0x1b, 0x5b, 0x14,
-	0x2b, 0x53, 0x1d, 0xf1, 0x89, 0xd6, 0xa1, 0xce, 0xb6, 0x1c, 0x19, 0x9e, 0x31, 0x14, 0x8a, 0xf3,
-	0x92, 0xd4, 0xf8, 0x6e, 0xe3, 0xfd, 0x07, 0xc4, 0x8e, 0xb7, 0x0d, 0xcb, 0xd3, 0x19, 0xa3, 0xb7,
-	0xe9, 0x2a, 0xb4, 0x08, 0x2a, 0xdb, 0x65, 0xc7, 0xb2, 0x31, 0x57, 0xc1, 0x19, 0x1a, 0x3c, 0x9b,
-	0x14, 0x7e, 0xcb, 0xb2, 0x31, 0xd3, 0xb2, 0xf0, 0x08, 0x94, 0xb5, 0x15, 0xa6, 0x64, 0x14, 0x42,
-	0x19, 0x7b, 0x01, 0x1a, 0x6c, 0x78, 0x0f, 0x7b, 0xbe, 0xe5, 0x3a, 0xdc, 0x53, 0x32, 0x1a, 0x1f,
-	0x30, 0x18, 0x8d, 0xdf, 0xe3, 0x21, 0x53, 0x53, 0x60, 0xc7, 0x71, 0xc6, 0x43, 0xa2, 0xa4, 0xda,
-	0x37, 0x4a, 0x30, 0x4f, 0x6c, 0x95, 0x9b, 0xed, 0x31, 0x22, 0xe1, 0x19, 0x00, 0xd3, 0x0f, 0xba,
-	0x09, 0xff, 0x52, 0x35, 0xfd, 0x80, 0xf9, 0x49, 0xf4, 0x96, 0x08, 0x64, 0xc5, 0xfc, 0xdc, 0x36,
-	0xe5, 0x3b, 0xb2, 0xc1, 0xec, 0x48, 0x95, 0xff, 0x05, 0x68, 0xf8, 0xee, 0xd8, 0xeb, 0xe3, 0x6e,
-	0xa2, 0x0a, 0xa9, 0x33, 0xe0, 0x96, 0xdc, 0x03, 0x4e, 0x4b, 0x3b, 0x10, 0xb1, 0x80, 0x36, 0x73,
-	0xbc, 0x80, 0x56, 0x49, 0x07, 0xb4, 0xdb, 0x30, 0x4b, 0xcd, 0xb7, 0x3b, 0x72, 0x7d, 0x56, 0xcc,
-	0x71, 0xab, 0xd7, 0x72, 0x8a, 0xf9, 0xbb, 0xfe, 0x60, 0x9b, 0x4f, 0xd5, 0x9b, 0x74, 0xa9, 0xf8,
-	0xf4, 0x89, 0xfa, 0x0a, 0x7d, 0xe0, 0xf2, 0xe6, 0x9f, 0x84, 0x19, 0x0e, 0xc6, 0x66, 0x37, 0xf0,
-	0x0c, 0xc7, 0xdf, 0xc1, 0x1e, 0x0d, 0x6a, 0x15, 0xbd, 0x4e, 0x80, 0xf7, 0x38, 0x4c, 0xfb, 0x4d,
-	0x01, 0x16, 0x78, 0x6d, 0x79, 0x7c, 0xbd, 0xc8, 0x8b, 0x39, 0xc2, 0x69, 0x17, 0x0f, 0xa8, 0xd6,
-	0x4a, 0x13, 0x64, 0x4d, 0x65, 0x49, 0xd6, 0x94, 0xac, 0x58, 0xa6, 0x33, 0x15, 0x4b, 0xd8, 0x7f,
-	0x98, 0x99, 0xbc, 0xff, 0x80, 0x4e, 0x40, 0x99, 0xa6, 0xd1, 0x54, 0x76, 0x55, 0x9d, 0x7d, 0x4c,
-	0xc6, 0xd0, 0x3f, 0x2a, 0xd0, 0xe8, 0x60, 0xc3, 0xeb, 0xef, 0x0a, 0x3e, 0xbe, 0x19, 0xef, 0xd7,
-	0x5c, 0xcc, 0x11, 0x71, 0x62, 0xc9, 0x17, 0xa7, 0x51, 0xf3, 0x27, 0x05, 0xea, 0xff, 0x41, 0x86,
-	0xc4, 0x61, 0xaf, 0xc7, 0x0f, 0x7b, 0x39, 0xe7, 0xb0, 0x3a, 0x0e, 0x3c, 0x0b, 0xef, 0xe1, 0x2f,
-	0xdc, 0x71, 0x7f, 0xa5, 0x40, 0xbb, 0xb3, 0xef, 0xf4, 0x75, 0x66, 0xcb, 0xc7, 0xb7, 0x98, 0x0b,
-	0xd0, 0xd8, 0x4b, 0xa4, 0x5a, 0x05, 0xaa, 0x70, 0xf5, 0xbd, 0x78, 0x4d, 0xa6, 0x83, 0x2a, 0xda,
-	0x44, 0xfc, 0xb0, 0xc2, 0xb5, 0xbe, 0x2c, 0xa3, 0x3a, 0x45, 0x1c, 0x75, 0x4d, 0xb3, 0x5e, 0x12,
-	0xa8, 0x7d, 0x4d, 0x81, 0x79, 0xc9, 0x44, 0x74, 0x0a, 0x66, 0x78, 0xfd, 0xc7, 0x63, 0x30, 0xb3,
-	0x61, 0x93, 0x88, 0x27, 0xea, 0x60, 0x58, 0x66, 0x36, 0x7f, 0x33, 0xd1, 0x39, 0xa8, 0x85, 0x89,
-	0xba, 0x99, 0x91, 0x8f, 0xe9, 0xa3, 0x36, 0x54, 0xb8, 0x73, 0x12, 0x15, 0x50, 0xf8, 0xad, 0xfd,
-	0x4c, 0x81, 0x85, 0xf7, 0x0c, 0xc7, 0x74, 0x77, 0x76, 0x8e, 0xcf, 0xd6, 0x35, 0x48, 0xe4, 0xf7,
-	0x93, 0x76, 0x0e, 0x92, 0x45, 0xc1, 0x15, 0x98, 0xf3, 0x98, 0x67, 0x34, 0x93, 0x7c, 0x2f, 0xea,
-	0xaa, 0x18, 0x08, 0xf9, 0xf9, 0x51, 0x01, 0x10, 0x09, 0x06, 0x37, 0x0d, 0xdb, 0x70, 0xfa, 0xf8,
-	0xe8, 0xa4, 0x5f, 0x82, 0x66, 0x22, 0x84, 0x85, 0x17, 0x2c, 0xf1, 0x18, 0xe6, 0xa3, 0xdb, 0xd0,
-	0xec, 0x31, 0x54, 0x5d, 0x0f, 0x1b, 0xbe, 0xeb, 0x50, 0xe7, 0xda, 0x94, 0x37, 0x09, 0xee, 0x79,
-	0xd6, 0x60, 0x80, 0xbd, 0x35, 0xd7, 0x31, 0x59, 0x10, 0x69, 0xf4, 0x04, 0x99, 0x64, 0x29, 0x11,
-	0x5c, 0x14, 0xcf, 0x85, 0x68, 0x20, 0x0c, 0xe8, 0x94, 0x15, 0x3e, 0x36, 0xec, 0x88, 0x11, 0x91,
-	0x37, 0x56, 0xd9, 0x40, 0x27, 0xbf, 0x47, 0x24, 0x89, 0xaf, 0xda, 0x8f, 0x15, 0x40, 0x61, 0x91,
-	0x43, 0x8b, 0x36, 0xaa, 0x7d, 0xe9, 0xa5, 0x8a, 0x24, 0x28, 0x9c, 0x86, 0xaa, 0x29, 0x56, 0x72,
-	0x73, 0x89, 0x00, 0xd4, 0x47, 0x53, 0xa2, 0xbb, 0x24, 0x18, 0x63, 0x53, 0x14, 0x11, 0x0c, 0x78,
-	0x87, 0xc2, 0x92, 0xe1, 0xb9, 0x94, 0x0e, 0xcf, 0xf1, 0x16, 0x48, 0x39, 0xd1, 0x02, 0xd1, 0x3e,
-	0x2e, 0x80, 0x4a, 0xdd, 0xdd, 0x5a, 0x54, 0x87, 0x4f, 0x44, 0xf4, 0x05, 0x68, 0xf0, 0x2b, 0xc8,
-	0x04, 0xe1, 0xf5, 0xc7, 0xb1, 0xcd, 0xd0, 0x55, 0x38, 0xc1, 0x26, 0x79, 0xd8, 0x1f, 0xdb, 0x51,
-	0xfe, 0xcc, 0x92, 0x59, 0xf4, 0x98, 0xf9, 0x59, 0x32, 0x24, 0x56, 0xdc, 0x87, 0x85, 0x81, 0xed,
-	0xf6, 0x0c, 0xbb, 0x9b, 0x14, 0x0f, 0x93, 0xe1, 0x04, 0x1a, 0x7f, 0x82, 0x2d, 0xef, 0xc4, 0x65,
-	0xe8, 0xa3, 0x0d, 0x52, 0x71, 0xe3, 0x47, 0x61, 0x7e, 0xc2, 0xbb, 0xdb, 0x93, 0xa4, 0x27, 0x75,
-	0xb2, 0x50, 0x7c, 0x69, 0xdf, 0x51, 0x60, 0x36, 0xd5, 0xc5, 0x4c, 0xd7, 0x81, 0x4a, 0xb6, 0x0e,
-	0xbc, 0x0e, 0x65, 0x52, 0x1c, 0x31, 0x67, 0xd8, 0x94, 0xd7, 0x28, 0xc9, 0x5d, 0x75, 0xb6, 0x00,
-	0xad, 0xc0, 0xbc, 0xe4, 0xbe, 0x8b, 0xeb, 0x00, 0xca, 0x5e, 0x77, 0x69, 0xbf, 0x2b, 0x41, 0x2d,
-	0xc6, 0x8f, 0x43, 0x4a, 0xd8, 0x49, 0xda, 0x52, 0xa9, 0xe3, 0x15, 0xb3, 0xc7, 0xcb, 0xb9, 0xf0,
-	0x21, 0x7a, 0x37, 0xc4, 0x43, 0x96, 0xfc, 0xf3, 0x4a, 0x64, 0x88, 0x87, 0x34, 0xf5, 0x8f, 0x67,
-	0xf5, 0xd3, 0x89, 0xac, 0x3e, 0x55, 0xf7, 0xcc, 0x1c, 0x50, 0xf7, 0x54, 0x92, 0x75, 0x4f, 0xc2,
-	0x8e, 0xaa, 0x69, 0x3b, 0x9a, 0xb4, 0xaa, 0xbc, 0x0a, 0xf3, 0x7d, 0x0f, 0x1b, 0x01, 0x36, 0x6f,
-	0xee, 0xaf, 0x85, 0x43, 0x3c, 0x33, 0x92, 0x0d, 0xa1, 0x5b, 0x51, 0x3b, 0x87, 0x49, 0xb9, 0x4e,
-	0xa5, 0x2c, 0x2f, 0xab, 0xb8, 0x6c, 0x98, 0x90, 0x85, 0x7b, 0xa6, 0x5f, 0xe9, 0x7a, 0xb6, 0x71,
-	0xa4, 0x7a, 0xf6, 0x1c, 0xd4, 0x44, 0x68, 0x25, 0xe6, 0xde, 0x64, 0x9e, 0x4f, 0xf8, 0x02, 0xd3,
-	0x4f, 0x38, 0x83, 0xd9, 0x64, 0x3f, 0x34, 0x5d, 0x94, 0xaa, 0x99, 0xa2, 0x54, 0xfb, 0x6d, 0x11,
-	0x9a, 0x51, 0xb1, 0x32, 0xb1, 0xb7, 0x98, 0xe4, 0x6a, 0x77, 0x0b, 0xd4, 0x28, 0x1e, 0x53, 0x46,
-	0x1e, 0x58, 0x6f, 0xa5, 0xef, 0x12, 0x66, 0x47, 0x29, 0xb3, 0x4c, 0x74, 0x6b, 0x4b, 0xcf, 0xd4,
-	0xad, 0x3d, 0xe6, 0x2d, 0xd8, 0x35, 0x38, 0x19, 0xc6, 0xd9, 0xc4, 0xb1, 0x59, 0x32, 0x7f, 0x42,
-	0x0c, 0x6e, 0xc7, 0x8f, 0x9f, 0x63, 0xe9, 0x33, 0x79, 0x96, 0x9e, 0x96, 0x74, 0x25, 0x23, 0xe9,
-	0xec, 0x65, 0x5c, 0x55, 0x76, 0x19, 0x77, 0x1f, 0xe6, 0x69, 0x8b, 0xce, 0xef, 0x7b, 0x56, 0x0f,
-	0x87, 0xa9, 0xe9, 0x24, 0x62, 0x6d, 0x43, 0x25, 0x95, 0xdd, 0x86, 0xdf, 0xda, 0x97, 0x14, 0x58,
-	0xc8, 0xee, 0x4b, 0x35, 0x26, 0xf2, 0x17, 0x4a, 0xc2, 0x5f, 0xfc, 0x17, 0xcc, 0x47, 0xdb, 0x27,
-	0xf3, 0xe6, 0x9c, 0xcc, 0x50, 0x42, 0xb8, 0x8e, 0xa2, 0x3d, 0x04, 0x4c, 0xfb, 0x8b, 0x12, 0x76,
-	0x3a, 0x09, 0x6c, 0x40, 0xbb, 0xbc, 0x24, 0x86, 0xb9, 0x8e, 0x6d, 0x39, 0x61, 0x71, 0xcd, 0xcf,
-	0xc8, 0x80, 0xbc, 0xb8, 0x7e, 0x0f, 0x66, 0xf9, 0xa4, 0x30, 0x14, 0x4d, 0x98, 0x7c, 0x35, 0xd9,
-	0xba, 0x30, 0x08, 0x5d, 0x82, 0x26, 0x6f, 0xbf, 0x0a, 0x7c, 0x45, 0x49, 0x53, 0x16, 0xfd, 0x3b,
-	0xa8, 0x62, 0xda, 0xb3, 0x06, 0xbf, 0x59, 0xbe, 0x30, 0x4c, 0xe2, 0xfe, 0x5f, 0x81, 0x56, 0x32,
-	0x14, 0xc6, 0x8e, 0xff, 0xec, 0xa9, 0xdc, 0xbf, 0x24, 0x2f, 0xae, 0x2e, 0x1d, 0x40, 0x4f, 0x84,
-	0x47, 0x5c, 0x5f, 0x6d, 0xd1, 0x4b, 0x48, 0x52, 0x81, 0xac, 0x5b, 0x7e, 0xe0, 0x59, 0xbd, 0xf1,
-	0xb1, 0x9e, 0x27, 0x68, 0x3f, 0x29, 0xc0, 0x8b, 0xd2, 0x0d, 0x8f, 0x73, 0x45, 0x95, 0x57, 0xf0,
-	0xdf, 0x84, 0x4a, 0xaa, 0x52, 0xb9, 0x7c, 0xc0, 0xe1, 0x79, 0xef, 0x8a, 0xf5, 0x50, 0xc4, 0x3a,
-	0xb2, 0x47, 0xa8, 0xd3, 0xa5, 0xfc, 0x3d, 0xb8, 0xd2, 0x26, 0xf6, 0x10, 0xeb, 0xd0, 0x0d, 0xa8,
-	0xb3, 0x2a, 0xb0, 0xbb, 0x67, 0xe1, 0x27, 0xe2, 0x66, 0xe5, 0xac, 0xd4, 0xaf, 0xd1, 0x79, 0x0f,
-	0x2c, 0xfc, 0x44, 0xaf, 0xd9, 0xe1, 0x6f, 0x5f, 0xfb, 0x61, 0x01, 0x20, 0x1a, 0x23, 0x25, 0x68,
-	0x64, 0x30, 0xdc, 0x02, 0x62, 0x10, 0x12, 0x6f, 0x93, 0x29, 0x9e, 0xf8, 0x44, 0x7a, 0xd4, 0x3a,
-	0x35, 0x2d, 0x3f, 0xe0, 0x7c, 0x59, 0x39, 0x98, 0x16, 0xc1, 0x22, 0x22, 0x32, 0x76, 0x71, 0x21,
-	0x4a, 0x2c, 0x02, 0x41, 0xaf, 0x02, 0x1a, 0x78, 0xee, 0x13, 0xcb, 0x19, 0xc4, 0x13, 0x73, 0x96,
-	0xbf, 0xcf, 0xf1, 0x91, 0x28, 0x33, 0x6f, 0x77, 0x41, 0x4d, 0xef, 0x27, 0xb9, 0xbf, 0x78, 0x23,
-	0x79, 0x7f, 0x71, 0x90, 0x19, 0x91, 0x6d, 0xe2, 0x17, 0x18, 0xff, 0x1a, 0x66, 0x53, 0x94, 0xbc,
-	0x3c, 0xcf, 0x15, 0xeb, 0x59, 0x15, 0x12, 0x3d, 0x2b, 0xed, 0x9b, 0x0a, 0xa0, 0xac, 0x56, 0xa0,
-	0x26, 0x14, 0xc2, 0x4d, 0x0a, 0x9b, 0xeb, 0x29, 0x29, 0x14, 0x32, 0x52, 0x38, 0x0d, 0xd5, 0x30,
-	0x92, 0x70, 0xb7, 0x11, 0x01, 0xe2, 0x32, 0x2a, 0x25, 0x65, 0x14, 0x23, 0xac, 0x9c, 0x24, 0x6c,
-	0x17, 0x50, 0x56, 0xd3, 0xe2, 0x3b, 0x29, 0xc9, 0x9d, 0x0e, 0xa3, 0x30, 0x86, 0xa9, 0x98, 0xc4,
-	0xf4, 0x6b, 0x05, 0x50, 0x14, 0x2b, 0xc3, 0xcb, 0x95, 0x49, 0x02, 0xcc, 0x0a, 0xcc, 0x67, 0x23,
-	0xa9, 0x48, 0x1f, 0x50, 0x26, 0x8e, 0xca, 0x62, 0x5e, 0x51, 0x12, 0xf3, 0xd0, 0x9b, 0xa1, 0x6f,
-	0x60, 0x89, 0xc1, 0xd9, 0xbc, 0xc4, 0x20, 0xe9, 0x1e, 0xb4, 0x9f, 0x2a, 0x30, 0x17, 0x62, 0x7b,
-	0xa6, 0x93, 0x1c, 0x7e, 0x59, 0xf4, 0x09, 0x93, 0xde, 0x81, 0x19, 0xde, 0x1e, 0xc9, 0x28, 0xdf,
-	0x24, 0x55, 0xc0, 0x09, 0x28, 0x13, 0x5d, 0x17, 0xfd, 0x02, 0xf6, 0xa1, 0xfd, 0x48, 0x01, 0xe8,
-	0xec, 0x3b, 0xfd, 0x1b, 0x4c, 0x07, 0xae, 0x42, 0xe9, 0xb0, 0xbb, 0x71, 0x32, 0x9b, 0x66, 0x5b,
-	0x74, 0xe6, 0x04, 0x6c, 0x49, 0x14, 0x30, 0xc5, 0x74, 0x01, 0x93, 0x57, 0x7a, 0xe4, 0xeb, 0xfd,
-	0x2f, 0x15, 0x38, 0x45, 0x88, 0x78, 0x2e, 0x41, 0x68, 0x22, 0xd6, 0xc5, 0x6c, 0xaa, 0x98, 0xb4,
-	0xa9, 0xeb, 0x30, 0xc3, 0x6a, 0x08, 0x11, 0x10, 0xce, 0xe6, 0xb1, 0x8c, 0x31, 0x58, 0x17, 0xd3,
-	0x97, 0xfe, 0x0d, 0xaa, 0x61, 0x2f, 0x0f, 0xd5, 0x60, 0xe6, 0xbe, 0x73, 0xdb, 0x71, 0x9f, 0x38,
-	0xea, 0x14, 0x9a, 0x81, 0xe2, 0x0d, 0xdb, 0x56, 0x15, 0xd4, 0x80, 0x6a, 0x27, 0xf0, 0xb0, 0x31,
-	0xb4, 0x9c, 0x81, 0x5a, 0x40, 0x4d, 0x80, 0xf7, 0x2c, 0x3f, 0x70, 0x3d, 0xab, 0x6f, 0xd8, 0x6a,
-	0x71, 0xe9, 0x43, 0x68, 0x26, 0x53, 0x68, 0x54, 0x87, 0xca, 0x96, 0x1b, 0xbc, 0xfb, 0xd4, 0xf2,
-	0x03, 0x75, 0x8a, 0xcc, 0xdf, 0x72, 0x83, 0x6d, 0x0f, 0xfb, 0xd8, 0x09, 0x54, 0x05, 0x01, 0x4c,
-	0xbf, 0xef, 0xac, 0x5b, 0xfe, 0x23, 0xb5, 0x80, 0xe6, 0x79, 0x11, 0x6c, 0xd8, 0x9b, 0x3c, 0x2f,
-	0x55, 0x8b, 0x64, 0x79, 0xf8, 0x55, 0x42, 0x2a, 0xd4, 0xc3, 0x29, 0x1b, 0xdb, 0xf7, 0xd5, 0x32,
-	0xaa, 0x42, 0x99, 0xfd, 0x9c, 0x5e, 0x32, 0x41, 0x4d, 0x77, 0x70, 0xc8, 0x9e, 0xec, 0x10, 0x21,
-	0x48, 0x9d, 0x22, 0x27, 0xe3, 0x2d, 0x34, 0x55, 0x41, 0xb3, 0x50, 0x8b, 0x35, 0xa4, 0xd4, 0x02,
-	0x01, 0x6c, 0x78, 0xa3, 0x3e, 0x97, 0x1e, 0x23, 0x81, 0x24, 0x51, 0xeb, 0x84, 0x13, 0xa5, 0xa5,
-	0x9b, 0x50, 0x11, 0xb9, 0x3d, 0x99, 0xca, 0x59, 0x44, 0x3e, 0xd5, 0x29, 0x34, 0x07, 0x8d, 0xc4,
-	0x7b, 0x3c, 0x55, 0x41, 0x08, 0x9a, 0xc9, 0x77, 0xa2, 0x6a, 0x61, 0x69, 0x15, 0x20, 0xb2, 0x25,
-	0x42, 0xce, 0xa6, 0xb3, 0x67, 0xd8, 0x96, 0xc9, 0x68, 0x23, 0x43, 0x84, 0xbb, 0x94, 0x3b, 0xac,
-	0x15, 0xa3, 0x16, 0x96, 0xce, 0x41, 0x45, 0x68, 0x39, 0x81, 0xeb, 0x78, 0xe8, 0xee, 0x61, 0x26,
-	0x99, 0x0e, 0x0e, 0x54, 0x65, 0xf5, 0x5b, 0x0d, 0x00, 0xd6, 0x74, 0x71, 0x5d, 0xcf, 0x44, 0x36,
-	0xa0, 0x0d, 0x1c, 0x90, 0x82, 0xd2, 0x75, 0x44, 0x31, 0xe8, 0xa3, 0xe5, 0xa4, 0x2a, 0xf0, 0x8f,
-	0xec, 0x44, 0x7e, 0xfa, 0xf6, 0x45, 0xe9, 0xfc, 0xd4, 0x64, 0x6d, 0x0a, 0x0d, 0x29, 0xb6, 0x7b,
-	0xd6, 0x10, 0xdf, 0xb3, 0xfa, 0x8f, 0xc2, 0x4e, 0x4d, 0xfe, 0xab, 0xcb, 0xd4, 0x54, 0x81, 0xef,
-	0x82, 0x14, 0x5f, 0x27, 0xf0, 0x2c, 0x67, 0x20, 0x72, 0x30, 0x6d, 0x0a, 0x3d, 0x4e, 0xbd, 0xf9,
-	0x14, 0x08, 0x57, 0x27, 0x79, 0xe6, 0x79, 0x34, 0x94, 0x36, 0xcc, 0xa6, 0x1e, 0x88, 0xa3, 0x25,
-	0xf9, 0x4b, 0x23, 0xd9, 0x63, 0xf6, 0xf6, 0x95, 0x89, 0xe6, 0x86, 0xd8, 0x2c, 0x68, 0x26, 0x1f,
-	0x41, 0xa3, 0x7f, 0xca, 0xdb, 0x20, 0xf3, 0xd6, 0xb1, 0xbd, 0x34, 0xc9, 0xd4, 0x10, 0xd5, 0x43,
-	0xa6, 0xa0, 0x87, 0xa1, 0x92, 0xbe, 0x33, 0x6d, 0x1f, 0x94, 0xfe, 0x6a, 0x53, 0xe8, 0x7f, 0x60,
-	0x2e, 0xf3, 0x22, 0x13, 0xbd, 0x22, 0xef, 0xc6, 0xcb, 0x1f, 0x6e, 0x1e, 0x86, 0xe1, 0x61, 0xda,
-	0xbc, 0xf2, 0xa9, 0xcf, 0xbc, 0x5e, 0x9e, 0x9c, 0xfa, 0xd8, 0xf6, 0x07, 0x51, 0xff, 0xcc, 0x18,
-	0xc6, 0xd4, 0x6c, 0xd2, 0xad, 0xbf, 0x57, 0x65, 0x28, 0x72, 0x9f, 0x85, 0xb6, 0x97, 0x27, 0x9d,
-	0x1e, 0xd7, 0xae, 0xe4, 0xcb, 0x43, 0x39, 0xd3, 0xa4, 0xaf, 0x25, 0xe5, 0xda, 0x25, 0x7f, 0xc8,
-	0xa8, 0x4d, 0xa1, 0x7b, 0x09, 0xf7, 0x8a, 0x2e, 0xe7, 0x09, 0x27, 0x79, 0x21, 0x70, 0x18, 0xdf,
-	0xfe, 0x17, 0x10, 0xb3, 0x1d, 0x67, 0xc7, 0x1a, 0x8c, 0x3d, 0x83, 0x29, 0x56, 0x9e, 0xbb, 0xc9,
-	0x4e, 0x15, 0x68, 0x5e, 0x7b, 0x86, 0x15, 0xe1, 0x91, 0xba, 0x00, 0x1b, 0x38, 0xb8, 0x8b, 0x03,
-	0xcf, 0xea, 0xfb, 0xe9, 0x13, 0x45, 0x1e, 0x95, 0x4f, 0x10, 0xa8, 0x5e, 0x3e, 0x74, 0x5e, 0x88,
-	0xa0, 0x07, 0xb5, 0x0d, 0x1c, 0xf0, 0xbc, 0xca, 0x47, 0xb9, 0x2b, 0xc5, 0x0c, 0x81, 0x62, 0xf1,
-	0xf0, 0x89, 0x71, 0x77, 0x96, 0x7a, 0x85, 0x89, 0x72, 0x05, 0x9b, 0x7d, 0x1b, 0x2a, 0x77, 0x67,
-	0x39, 0xcf, 0x3a, 0xb5, 0xa9, 0xd5, 0x8f, 0x9b, 0x50, 0xa5, 0xb1, 0x89, 0x04, 0xd2, 0x7f, 0x84,
-	0xa6, 0xe7, 0x1c, 0x9a, 0x3e, 0x80, 0xd9, 0xd4, 0x83, 0x3e, 0xb9, 0x2c, 0xe5, 0xaf, 0xfe, 0x26,
-	0xf0, 0xb0, 0xc9, 0xc7, 0x76, 0x72, 0x67, 0x21, 0x7d, 0x90, 0x77, 0xd8, 0xde, 0x0f, 0xd8, 0x5b,
-	0xd8, 0xb0, 0x99, 0xf5, 0x72, 0x6e, 0xd9, 0x91, 0xbc, 0xeb, 0xfc, 0xec, 0x3d, 0xf7, 0x27, 0x1f,
-	0xd9, 0x3e, 0x80, 0xd9, 0xd4, 0x8b, 0x13, 0xb9, 0x54, 0xe5, 0xcf, 0x52, 0x0e, 0xdb, 0xfd, 0x53,
-	0x0c, 0x01, 0x26, 0xcc, 0x4b, 0x1e, 0x03, 0xa0, 0xe5, 0xbc, 0xaa, 0x44, 0xfe, 0x6a, 0xe0, 0xf0,
-	0x03, 0x35, 0x12, 0xa6, 0x84, 0x16, 0xf3, 0x88, 0x4c, 0xff, 0xdf, 0xa7, 0xfd, 0xca, 0x64, 0x7f,
-	0x0e, 0x0a, 0x0f, 0xd4, 0x81, 0x69, 0xf6, 0x0e, 0x05, 0xbd, 0x24, 0x6f, 0xfa, 0xc4, 0xde, 0xa8,
-	0xb4, 0x0f, 0x7b, 0xc9, 0xe2, 0x8f, 0xed, 0xc0, 0xa7, 0x9b, 0x96, 0xa9, 0x87, 0x44, 0xd2, 0x07,
-	0x54, 0xf1, 0xc7, 0x23, 0xed, 0xc3, 0xdf, 0x8b, 0x88, 0x4d, 0xff, 0xbe, 0xe3, 0xe4, 0x53, 0x98,
-	0x97, 0xb4, 0x6a, 0x51, 0x5e, 0x3e, 0x94, 0xd3, 0x24, 0x6e, 0xaf, 0x4c, 0x3c, 0x3f, 0xc4, 0xfc,
-	0xdf, 0xa0, 0xa6, 0xab, 0x7d, 0x74, 0x25, 0x4f, 0x9f, 0x65, 0x38, 0x0f, 0x56, 0xe6, 0x9b, 0xaf,
-	0x3f, 0x5c, 0x1d, 0x58, 0xc1, 0xee, 0xb8, 0x47, 0x46, 0x56, 0xd8, 0xd4, 0x57, 0x2d, 0x97, 0xff,
-	0x5a, 0x11, 0xfc, 0x5f, 0xa1, 0xab, 0x57, 0x28, 0xaa, 0x51, 0xaf, 0x37, 0x4d, 0x3f, 0xaf, 0xfd,
-	0x2d, 0x00, 0x00, 0xff, 0xff, 0x8f, 0xa9, 0xd4, 0xdf, 0xc7, 0x3b, 0x00, 0x00,
+	// 3606 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3b, 0x49, 0x6f, 0x1c, 0x57,
+	0x7a, 0xac, 0x5e, 0xc8, 0xee, 0xaf, 0x17, 0x16, 0x1f, 0x25, 0xaa, 0xdd, 0xd6, 0x42, 0x97, 0x16,
+	0x33, 0x94, 0x4d, 0xca, 0x94, 0x6d, 0xc8, 0xb1, 0x0d, 0x47, 0x22, 0x2d, 0x9a, 0x91, 0x44, 0x33,
+	0xd5, 0x92, 0x12, 0x08, 0x46, 0xda, 0xd5, 0x5d, 0x8f, 0xcd, 0x82, 0xaa, 0xab, 0x5a, 0x55, 0xd5,
+	0x94, 0xe8, 0x5c, 0x73, 0x89, 0x91, 0x04, 0x48, 0x0e, 0x01, 0x02, 0x04, 0x39, 0x25, 0x40, 0x12,
+	0xd8, 0x41, 0x0e, 0x09, 0x90, 0x43, 0x10, 0x0c, 0x30, 0x87, 0x99, 0xd3, 0x60, 0x7e, 0xc0, 0x00,
+	0xf3, 0x03, 0x66, 0x80, 0x39, 0xcd, 0x61, 0x6e, 0x83, 0xb7, 0xd5, 0xfa, 0x8a, 0x6c, 0x91, 0x92,
+	0x97, 0xc1, 0xdc, 0xba, 0xbe, 0xb7, 0x7c, 0xdf, 0xfb, 0xf6, 0xef, 0x7b, 0xaf, 0x61, 0xee, 0xc9,
+	0x18, 0x7b, 0x07, 0xdd, 0xbe, 0xeb, 0x7a, 0xe6, 0xca, 0xc8, 0x73, 0x03, 0x17, 0xa1, 0xa1, 0x65,
+	0xef, 0x8f, 0x7d, 0xf6, 0xb5, 0x42, 0xc7, 0xdb, 0xf5, 0xbe, 0x3b, 0x1c, 0xba, 0x0e, 0x83, 0xb5,
+	0xeb, 0xf1, 0x19, 0xed, 0xa6, 0xe5, 0x04, 0xd8, 0x73, 0x0c, 0x5b, 0x8c, 0xfa, 0xfd, 0x3d, 0x3c,
+	0x34, 0xf8, 0x97, 0x6a, 0x1a, 0x81, 0x11, 0xdf, 0x5f, 0xfb, 0x4b, 0x05, 0x16, 0x3a, 0x7b, 0xee,
+	0xd3, 0x75, 0xd7, 0xb6, 0x71, 0x3f, 0xb0, 0x5c, 0xc7, 0xd7, 0xf1, 0x93, 0x31, 0xf6, 0x03, 0x74,
+	0x0d, 0x4a, 0x3d, 0xc3, 0xc7, 0x2d, 0x65, 0x51, 0x59, 0xaa, 0xad, 0x9d, 0x5d, 0x49, 0x50, 0xc2,
+	0x49, 0xb8, 0xe7, 0x0f, 0x6e, 0x19, 0x3e, 0xd6, 0xe9, 0x4c, 0x84, 0xa0, 0x64, 0xf6, 0xb6, 0x36,
+	0x5a, 0x85, 0x45, 0x65, 0xa9, 0xa8, 0xd3, 0xdf, 0xe8, 0x12, 0x34, 0xfa, 0xe1, 0xde, 0x5b, 0x1b,
+	0x7e, 0xab, 0xb8, 0x58, 0x5c, 0x2a, 0xea, 0x49, 0xa0, 0xf6, 0x73, 0x05, 0xce, 0x64, 0xc8, 0xf0,
+	0x47, 0xae, 0xe3, 0x63, 0x74, 0x1d, 0xa6, 0xfd, 0xc0, 0x08, 0xc6, 0x3e, 0xa7, 0xe4, 0x55, 0x29,
+	0x25, 0x1d, 0x3a, 0x45, 0xe7, 0x53, 0xb3, 0x68, 0x0b, 0x12, 0xb4, 0xe8, 0x2d, 0x38, 0x65, 0x39,
+	0xf7, 0xf0, 0xd0, 0xf5, 0x0e, 0xba, 0x23, 0xec, 0xf5, 0xb1, 0x13, 0x18, 0x03, 0x2c, 0x68, 0x9c,
+	0x17, 0x63, 0x3b, 0xd1, 0x10, 0x7a, 0x17, 0xce, 0x30, 0x29, 0xf9, 0xd8, 0xdb, 0xb7, 0xfa, 0xb8,
+	0x6b, 0xec, 0x1b, 0x96, 0x6d, 0xf4, 0x6c, 0xdc, 0x2a, 0x2d, 0x16, 0x97, 0x2a, 0xfa, 0x69, 0x3a,
+	0xdc, 0x61, 0xa3, 0x37, 0xc5, 0xa0, 0xf6, 0xaf, 0x0a, 0x9c, 0x26, 0x27, 0xdc, 0x31, 0xbc, 0xc0,
+	0x7a, 0x09, 0x7c, 0xd6, 0xa0, 0x1e, 0x3f, 0x5b, 0xab, 0x48, 0xc7, 0x12, 0x30, 0x32, 0x67, 0x24,
+	0xd0, 0x13, 0x9e, 0x94, 0xe8, 0x31, 0x13, 0x30, 0xed, 0x5f, 0xb8, 0x42, 0xc4, 0xe9, 0x3c, 0x89,
+	0x20, 0xd2, 0x38, 0x0b, 0x59, 0x9c, 0xc7, 0x10, 0x83, 0xf6, 0x65, 0x11, 0x4e, 0xdf, 0x75, 0x0d,
+	0x33, 0x52, 0x98, 0x6f, 0x9e, 0x9d, 0x1f, 0xc2, 0x34, 0xb3, 0xae, 0x56, 0x89, 0xe2, 0xba, 0x9c,
+	0xc4, 0xc5, 0x2d, 0x2f, 0xa2, 0xb0, 0x43, 0x01, 0x3a, 0x5f, 0x84, 0x2e, 0x43, 0xd3, 0xc3, 0x23,
+	0xdb, 0xea, 0x1b, 0x5d, 0x67, 0x3c, 0xec, 0x61, 0xaf, 0x55, 0x5e, 0x54, 0x96, 0xca, 0x7a, 0x83,
+	0x43, 0xb7, 0x29, 0x10, 0x7d, 0x0e, 0x8d, 0x5d, 0x0b, 0xdb, 0x66, 0xd7, 0x72, 0x4c, 0xfc, 0x6c,
+	0x6b, 0xa3, 0x35, 0xbd, 0x58, 0x5c, 0xaa, 0xad, 0xbd, 0xbf, 0x92, 0xf5, 0x0c, 0x2b, 0x52, 0x8e,
+	0xac, 0xdc, 0x26, 0xcb, 0xb7, 0xd8, 0xea, 0x8f, 0x9d, 0xc0, 0x3b, 0xd0, 0xeb, 0xbb, 0x31, 0x50,
+	0xfb, 0x23, 0x98, 0xcb, 0x4c, 0x41, 0x2a, 0x14, 0x1f, 0xe3, 0x03, 0xca, 0xc5, 0xa2, 0x4e, 0x7e,
+	0xa2, 0x53, 0x50, 0xde, 0x37, 0xec, 0x31, 0xe6, 0x7c, 0x62, 0x1f, 0x7f, 0x58, 0xb8, 0xa1, 0x68,
+	0xff, 0xa4, 0x40, 0x4b, 0xc7, 0x36, 0x36, 0x7c, 0xfc, 0x6d, 0xca, 0x63, 0x01, 0xa6, 0x1d, 0xd7,
+	0xc4, 0x5b, 0x1b, 0x54, 0x1e, 0x45, 0x9d, 0x7f, 0x69, 0xbf, 0x51, 0xe0, 0xd4, 0x26, 0x0e, 0x88,
+	0x62, 0x5a, 0x7e, 0x60, 0xf5, 0x43, 0xcb, 0xfb, 0x10, 0x8a, 0x1e, 0x7e, 0xc2, 0x29, 0xbb, 0x9a,
+	0xa4, 0x2c, 0xf4, 0xa3, 0xb2, 0x95, 0x3a, 0x59, 0x87, 0x5e, 0x83, 0xba, 0x39, 0xb4, 0xbb, 0xfd,
+	0x3d, 0xc3, 0x71, 0xb0, 0xcd, 0x54, 0xbb, 0xaa, 0xd7, 0xcc, 0xa1, 0xbd, 0xce, 0x41, 0xe8, 0x3c,
+	0x80, 0x8f, 0x07, 0x43, 0xec, 0x04, 0x91, 0xeb, 0x8b, 0x41, 0xd0, 0x32, 0xcc, 0xed, 0x7a, 0xee,
+	0xb0, 0xeb, 0xef, 0x19, 0x9e, 0xd9, 0xb5, 0xb1, 0x61, 0x62, 0x8f, 0x52, 0x5f, 0xd1, 0x67, 0xc9,
+	0x40, 0x87, 0xc0, 0xef, 0x52, 0x30, 0xba, 0x0e, 0x65, 0xbf, 0xef, 0x8e, 0x30, 0x55, 0x93, 0xe6,
+	0xda, 0x39, 0x99, 0x02, 0x6c, 0x18, 0x81, 0xd1, 0x21, 0x93, 0x74, 0x36, 0x57, 0xfb, 0x4f, 0x6e,
+	0x27, 0xdf, 0x71, 0xb7, 0x13, 0xb3, 0xa5, 0xf2, 0x8b, 0xb1, 0xa5, 0xe9, 0x89, 0x6c, 0x69, 0xe6,
+	0x70, 0x5b, 0xca, 0x70, 0xed, 0xe5, 0xdb, 0xd2, 0x0f, 0x22, 0x5b, 0xfa, 0xae, 0xcb, 0x2c, 0xb2,
+	0xb7, 0x72, 0xc2, 0xde, 0xfe, 0x5d, 0x81, 0x57, 0x36, 0x71, 0x10, 0x92, 0x4f, 0xcc, 0x07, 0x7f,
+	0x47, 0xc3, 0xdd, 0xd7, 0x0a, 0xb4, 0x65, 0xb4, 0x9e, 0x24, 0xe4, 0x3d, 0x82, 0x85, 0x10, 0x47,
+	0xd7, 0xc4, 0x7e, 0xdf, 0xb3, 0x46, 0x54, 0x8c, 0xd4, 0x43, 0xd4, 0xd6, 0x2e, 0xca, 0xd4, 0x2d,
+	0x4d, 0xc1, 0xe9, 0x70, 0x8b, 0x8d, 0xd8, 0x0e, 0xda, 0xdf, 0x28, 0x70, 0x9a, 0x78, 0x24, 0xee,
+	0x42, 0x9c, 0x5d, 0xf7, 0xf8, 0x7c, 0x4d, 0x3a, 0xa7, 0x42, 0xc6, 0x39, 0x4d, 0xc0, 0x63, 0x9a,
+	0x3f, 0xa6, 0xe9, 0x39, 0x09, 0xef, 0xde, 0x81, 0xb2, 0xe5, 0xec, 0xba, 0x82, 0x55, 0x17, 0x64,
+	0xac, 0x8a, 0x23, 0x63, 0xb3, 0x35, 0x87, 0x51, 0x11, 0x79, 0xcb, 0x13, 0xa8, 0x5b, 0xfa, 0xd8,
+	0x05, 0xc9, 0xb1, 0xff, 0x5a, 0x81, 0x33, 0x19, 0x84, 0x27, 0x39, 0xf7, 0x07, 0x30, 0x4d, 0x63,
+	0x80, 0x38, 0xf8, 0x25, 0xe9, 0xc1, 0x63, 0xe8, 0xee, 0x5a, 0x7e, 0xa0, 0xf3, 0x35, 0x9a, 0x0b,
+	0x6a, 0x7a, 0x8c, 0x44, 0x27, 0x1e, 0x99, 0xba, 0x8e, 0x31, 0x64, 0x0c, 0xa8, 0xea, 0x35, 0x0e,
+	0xdb, 0x36, 0x86, 0x18, 0xbd, 0x02, 0x15, 0x62, 0xb2, 0x5d, 0xcb, 0x14, 0xe2, 0x9f, 0xa1, 0x26,
+	0x6c, 0xfa, 0xe8, 0x1c, 0x00, 0x1d, 0x32, 0x4c, 0xd3, 0x63, 0x81, 0xab, 0xaa, 0x57, 0x09, 0xe4,
+	0x26, 0x01, 0x68, 0x7f, 0xa7, 0x40, 0x9d, 0x38, 0xc8, 0x7b, 0x38, 0x30, 0x88, 0x1c, 0xd0, 0x7b,
+	0x50, 0xb5, 0x5d, 0xc3, 0xec, 0x06, 0x07, 0x23, 0x86, 0xaa, 0x99, 0xe6, 0x75, 0xe4, 0x55, 0xef,
+	0x1f, 0x8c, 0xb0, 0x5e, 0xb1, 0xf9, 0xaf, 0x49, 0xf8, 0x9d, 0x31, 0xe5, 0xa2, 0xc4, 0x94, 0xbf,
+	0x2a, 0xc3, 0xc2, 0x9f, 0x1a, 0x41, 0x7f, 0x6f, 0x63, 0x28, 0xe2, 0xef, 0xf1, 0x95, 0x20, 0xf2,
+	0x6d, 0x85, 0xb8, 0x6f, 0x7b, 0x61, 0xbe, 0x33, 0xd4, 0xf3, 0xb2, 0x4c, 0xcf, 0x49, 0x99, 0xb6,
+	0xf2, 0x90, 0x8b, 0x2a, 0xa6, 0xe7, 0xb1, 0x30, 0x39, 0x7d, 0x9c, 0x30, 0xb9, 0x0e, 0x0d, 0xfc,
+	0xac, 0x6f, 0x8f, 0x89, 0xcc, 0x29, 0x76, 0x16, 0xff, 0xce, 0x4b, 0xb0, 0xc7, 0x8d, 0xac, 0xce,
+	0x17, 0x6d, 0x71, 0x1a, 0x98, 0xa8, 0x87, 0x38, 0x30, 0x5a, 0x15, 0x4a, 0xc6, 0x62, 0x9e, 0xa8,
+	0x85, 0x7e, 0x30, 0x71, 0x93, 0x2f, 0x74, 0x16, 0xaa, 0x3c, 0x28, 0x6f, 0x6d, 0xb4, 0xaa, 0x94,
+	0x7d, 0x11, 0x00, 0x19, 0xd0, 0xe0, 0x1e, 0x88, 0x53, 0x08, 0x94, 0xc2, 0x0f, 0x64, 0x08, 0xe4,
+	0xc2, 0x8e, 0x53, 0xee, 0xf3, 0x10, 0xed, 0xc7, 0x40, 0xa4, 0x34, 0x74, 0x77, 0x77, 0x6d, 0xcb,
+	0xc1, 0xdb, 0x4c, 0xc2, 0x35, 0x4a, 0x44, 0x12, 0xd8, 0xee, 0xc2, 0x5c, 0x66, 0x23, 0x49, 0x20,
+	0x7f, 0x3b, 0x1e, 0xc8, 0x8f, 0xe6, 0x64, 0x2c, 0xd0, 0xff, 0x9b, 0x02, 0xa7, 0x1f, 0x38, 0xfe,
+	0xb8, 0x17, 0x9e, 0xe0, 0xdb, 0xd1, 0xd6, 0xb4, 0x9f, 0x28, 0x65, 0xfc, 0x84, 0xf6, 0xff, 0x25,
+	0x98, 0xe5, 0xa7, 0x20, 0x42, 0xa5, 0x06, 0x7f, 0x16, 0xaa, 0x61, 0xa8, 0xe0, 0x0c, 0x89, 0x00,
+	0x68, 0x11, 0x6a, 0x31, 0x75, 0xe7, 0x54, 0xc5, 0x41, 0x13, 0x91, 0x26, 0x02, 0x7f, 0x29, 0x16,
+	0xf8, 0xcf, 0x01, 0xec, 0xda, 0x63, 0x7f, 0xaf, 0x1b, 0x58, 0x43, 0xcc, 0x13, 0x8f, 0x2a, 0x85,
+	0xdc, 0xb7, 0x86, 0x18, 0xdd, 0x84, 0x7a, 0xcf, 0x72, 0x6c, 0x77, 0xd0, 0x1d, 0x19, 0xc1, 0x9e,
+	0xcf, 0x8b, 0x25, 0x99, 0x58, 0x68, 0x9a, 0x76, 0x8b, 0xce, 0xd5, 0x6b, 0x6c, 0xcd, 0x0e, 0x59,
+	0x82, 0xce, 0x43, 0xcd, 0x19, 0x0f, 0xbb, 0xee, 0x6e, 0xd7, 0x73, 0x9f, 0x12, 0x13, 0xa1, 0x28,
+	0x9c, 0xf1, 0xf0, 0xd3, 0x5d, 0xdd, 0x7d, 0x4a, 0x5c, 0x75, 0x95, 0x38, 0x6d, 0xdf, 0x76, 0x07,
+	0x7e, 0xab, 0x32, 0xd1, 0xfe, 0xd1, 0x02, 0xb2, 0xda, 0xc4, 0x76, 0x60, 0xd0, 0xd5, 0xd5, 0xc9,
+	0x56, 0x87, 0x0b, 0xd0, 0x15, 0x68, 0xf6, 0xdd, 0xe1, 0xc8, 0xa0, 0x1c, 0xba, 0xed, 0xb9, 0x43,
+	0x6a, 0x1f, 0x45, 0x3d, 0x05, 0x45, 0xeb, 0x50, 0xa3, 0x29, 0x2e, 0x37, 0xa2, 0x1a, 0xc5, 0xa3,
+	0xc9, 0x8c, 0x28, 0x96, 0xad, 0x12, 0x05, 0x05, 0x4b, 0xfc, 0xf4, 0x89, 0x66, 0x08, 0x5b, 0xf4,
+	0xad, 0x2f, 0x70, 0xab, 0xce, 0xa4, 0xc8, 0x61, 0x1d, 0xeb, 0x0b, 0x4c, 0xf2, 0x6e, 0xcb, 0xf1,
+	0xb1, 0x17, 0x88, 0x2a, 0xa8, 0xd5, 0xa0, 0xea, 0xd3, 0x60, 0x50, 0xae, 0xd8, 0xda, 0xaf, 0x0a,
+	0xd0, 0x4c, 0x22, 0x42, 0x2d, 0x98, 0x61, 0x89, 0xb3, 0xd0, 0x1e, 0xf1, 0x49, 0xd0, 0x62, 0xc7,
+	0xe8, 0xd9, 0x98, 0x65, 0xe9, 0x54, 0x79, 0x2a, 0x7a, 0x8d, 0xc1, 0xe8, 0x06, 0x44, 0x09, 0xd8,
+	0xf1, 0xa8, 0xc6, 0x16, 0x29, 0xca, 0x2a, 0x85, 0xd0, 0xb8, 0xd6, 0x82, 0x19, 0x91, 0xe0, 0x33,
+	0xd5, 0x11, 0x9f, 0x64, 0xa4, 0x37, 0xb6, 0x28, 0x56, 0xa6, 0x3a, 0xe2, 0x13, 0x6d, 0x40, 0x9d,
+	0x6d, 0x39, 0x32, 0x3c, 0x63, 0x28, 0x14, 0xe7, 0x35, 0xa9, 0xf1, 0xdd, 0xc1, 0x07, 0x0f, 0x89,
+	0x1d, 0xef, 0x18, 0x96, 0xa7, 0x33, 0x46, 0xef, 0xd0, 0x55, 0x68, 0x09, 0x54, 0xb6, 0xcb, 0xae,
+	0x65, 0x63, 0xae, 0x82, 0x33, 0x34, 0x78, 0x36, 0x29, 0xfc, 0xb6, 0x65, 0x63, 0xa6, 0x65, 0xe1,
+	0x11, 0x28, 0x6b, 0x2b, 0x4c, 0xc9, 0x28, 0x84, 0x32, 0xf6, 0x22, 0x34, 0xd8, 0xf0, 0x3e, 0xf6,
+	0x7c, 0xcb, 0x75, 0xb8, 0xa7, 0x64, 0x34, 0x3e, 0x64, 0x30, 0x1a, 0xbf, 0xc7, 0x43, 0xa6, 0xa6,
+	0xc0, 0x8e, 0xe3, 0x8c, 0x87, 0x44, 0x49, 0xb5, 0xbf, 0x2f, 0xc1, 0x3c, 0xb1, 0x55, 0x6e, 0xb6,
+	0x27, 0x88, 0x84, 0xe7, 0x00, 0x4c, 0x3f, 0xe8, 0x26, 0xfc, 0x4b, 0xd5, 0xf4, 0x03, 0xe6, 0x27,
+	0xd1, 0x7b, 0x22, 0x90, 0x15, 0xf3, 0x73, 0xdb, 0x94, 0xef, 0xc8, 0x06, 0xb3, 0x63, 0xf5, 0x4f,
+	0x2e, 0x42, 0xc3, 0x77, 0xc7, 0x5e, 0x1f, 0x77, 0x13, 0x55, 0x48, 0x9d, 0x01, 0xb7, 0xe5, 0x1e,
+	0x70, 0x5a, 0xda, 0xc7, 0x89, 0x05, 0xb4, 0x99, 0x93, 0x05, 0xb4, 0x4a, 0x3a, 0xa0, 0xdd, 0x81,
+	0x59, 0x6a, 0xbe, 0xdd, 0x91, 0xeb, 0xb3, 0x62, 0x8e, 0x5b, 0xbd, 0x96, 0xd3, 0x6f, 0xb8, 0xe7,
+	0x0f, 0x76, 0xf8, 0x54, 0xbd, 0x49, 0x97, 0x8a, 0x4f, 0x9f, 0xa8, 0xaf, 0xd0, 0x07, 0x2e, 0x6f,
+	0xfe, 0x49, 0x98, 0xe1, 0x60, 0x6c, 0x76, 0x03, 0xcf, 0x70, 0xfc, 0x5d, 0xec, 0xd1, 0xa0, 0x56,
+	0xd1, 0xeb, 0x04, 0x78, 0x9f, 0xc3, 0xb4, 0x9f, 0x14, 0x60, 0x81, 0xd7, 0x96, 0x27, 0xd7, 0x8b,
+	0xbc, 0x98, 0x23, 0x9c, 0x76, 0xf1, 0x90, 0x6a, 0xad, 0x34, 0x41, 0xd6, 0x54, 0x96, 0x64, 0x4d,
+	0xc9, 0x8a, 0x65, 0x3a, 0x53, 0xb1, 0x84, 0x2d, 0x92, 0x99, 0xc9, 0x5b, 0x24, 0xa4, 0x16, 0xa7,
+	0x69, 0x34, 0x95, 0x5d, 0x55, 0x67, 0x1f, 0x93, 0x31, 0xf4, 0x17, 0x0a, 0x34, 0x3a, 0xd8, 0xf0,
+	0xfa, 0x7b, 0x82, 0x8f, 0xef, 0xc6, 0x5b, 0x4a, 0x97, 0x72, 0x44, 0x9c, 0x58, 0xf2, 0xfd, 0xe9,
+	0x25, 0xfd, 0x52, 0x81, 0xfa, 0x9f, 0x90, 0x21, 0x71, 0xd8, 0x1b, 0xf1, 0xc3, 0x5e, 0xc9, 0x39,
+	0xac, 0x8e, 0x03, 0xcf, 0xc2, 0xfb, 0xf8, 0x7b, 0x77, 0xdc, 0x1f, 0x29, 0xd0, 0xee, 0x1c, 0x38,
+	0x7d, 0x9d, 0xd9, 0xf2, 0xc9, 0x2d, 0xe6, 0x22, 0x34, 0xf6, 0x13, 0xa9, 0x56, 0x81, 0x2a, 0x5c,
+	0x7d, 0x3f, 0x5e, 0x93, 0xe9, 0xa0, 0x8a, 0x4e, 0x16, 0x3f, 0xac, 0x70, 0xad, 0xaf, 0xcb, 0xa8,
+	0x4e, 0x11, 0x47, 0x5d, 0xd3, 0xac, 0x97, 0x04, 0x6a, 0x7f, 0xab, 0xc0, 0xbc, 0x64, 0x22, 0x3a,
+	0x03, 0x33, 0xbc, 0xfe, 0xe3, 0x31, 0x98, 0xd9, 0xb0, 0x49, 0xc4, 0x13, 0x75, 0x30, 0x2c, 0x33,
+	0x9b, 0xbf, 0x99, 0xe8, 0x02, 0xd4, 0xc2, 0x44, 0xdd, 0xcc, 0xc8, 0xc7, 0xf4, 0x51, 0x1b, 0x2a,
+	0xdc, 0x39, 0x89, 0x0a, 0x28, 0xfc, 0xd6, 0xfe, 0x4f, 0x81, 0x85, 0x4f, 0x0c, 0xc7, 0x74, 0x77,
+	0x77, 0x4f, 0xce, 0xd6, 0x75, 0x48, 0xe4, 0xf7, 0x93, 0x76, 0x0e, 0x92, 0x45, 0xc1, 0x55, 0x98,
+	0xf3, 0x98, 0x67, 0x34, 0x93, 0x7c, 0x2f, 0xea, 0xaa, 0x18, 0x08, 0xf9, 0xf9, 0x55, 0x01, 0x10,
+	0x09, 0x06, 0xb7, 0x0c, 0xdb, 0x70, 0xfa, 0xf8, 0xf8, 0xa4, 0x5f, 0x86, 0x66, 0x22, 0x84, 0x85,
+	0xd7, 0x54, 0xf1, 0x18, 0xe6, 0xa3, 0x3b, 0xd0, 0xec, 0x31, 0x54, 0x5d, 0x0f, 0x1b, 0xbe, 0xeb,
+	0x50, 0xe7, 0xda, 0x94, 0x37, 0x09, 0xee, 0x7b, 0xd6, 0x60, 0x80, 0xbd, 0x75, 0xd7, 0x31, 0x59,
+	0x10, 0x69, 0xf4, 0x04, 0x99, 0x64, 0x29, 0x11, 0x5c, 0x14, 0xcf, 0x85, 0x68, 0x20, 0x0c, 0xe8,
+	0x94, 0x15, 0x3e, 0x36, 0xec, 0x88, 0x11, 0x91, 0x37, 0x56, 0xd9, 0x40, 0x27, 0xbf, 0x47, 0x24,
+	0x89, 0xaf, 0xda, 0x7f, 0x2b, 0x80, 0xc2, 0x22, 0x87, 0x16, 0x6d, 0x54, 0xfb, 0xd2, 0x4b, 0x15,
+	0x49, 0x50, 0x38, 0x0b, 0x55, 0x53, 0xac, 0xe4, 0xe6, 0x12, 0x01, 0xa8, 0x8f, 0xa6, 0x44, 0x77,
+	0x49, 0x30, 0xc6, 0xa6, 0x28, 0x22, 0x18, 0xf0, 0x2e, 0x85, 0x25, 0xc3, 0x73, 0x29, 0x1d, 0x9e,
+	0xe3, 0x2d, 0x90, 0x72, 0xa2, 0x05, 0xa2, 0x7d, 0x5d, 0x00, 0x95, 0xba, 0xbb, 0xf5, 0xa8, 0x0e,
+	0x9f, 0x88, 0xe8, 0x8b, 0xd0, 0xe0, 0x17, 0xb9, 0x09, 0xc2, 0xeb, 0x4f, 0x62, 0x9b, 0xa1, 0x6b,
+	0x70, 0x8a, 0x4d, 0xf2, 0xb0, 0x3f, 0xb6, 0xa3, 0xfc, 0x99, 0x25, 0xb3, 0xe8, 0x09, 0xf3, 0xb3,
+	0x64, 0x48, 0xac, 0x78, 0x00, 0x0b, 0x03, 0xdb, 0xed, 0x19, 0x76, 0x37, 0x29, 0x1e, 0x26, 0xc3,
+	0x09, 0x34, 0xfe, 0x14, 0x5b, 0xde, 0x89, 0xcb, 0xd0, 0x47, 0x9b, 0xa4, 0xe2, 0xc6, 0x8f, 0xc3,
+	0xfc, 0x84, 0x37, 0xe0, 0x27, 0x49, 0x4f, 0xea, 0x64, 0xa1, 0xf8, 0xd2, 0xfe, 0x59, 0x81, 0xd9,
+	0x54, 0x17, 0x33, 0x5d, 0x07, 0x2a, 0xd9, 0x3a, 0xf0, 0x06, 0x94, 0x49, 0x71, 0xc4, 0x9c, 0x61,
+	0x53, 0x5e, 0xa3, 0x24, 0x77, 0xd5, 0xd9, 0x02, 0xb4, 0x0a, 0xf3, 0x92, 0x5b, 0x43, 0xae, 0x03,
+	0x28, 0x7b, 0x69, 0xa8, 0xfd, 0xac, 0x04, 0xb5, 0x18, 0x3f, 0x8e, 0x28, 0x61, 0x27, 0x69, 0x4b,
+	0xa5, 0x8e, 0x57, 0xcc, 0x1e, 0x2f, 0xe7, 0x4e, 0x8a, 0xe8, 0xdd, 0x10, 0x0f, 0x59, 0xf2, 0xcf,
+	0x2b, 0x91, 0x21, 0x1e, 0xd2, 0xd4, 0x3f, 0x9e, 0xd5, 0x4f, 0x27, 0xb2, 0xfa, 0x54, 0xdd, 0x33,
+	0x73, 0x48, 0xdd, 0x53, 0x49, 0xd6, 0x3d, 0x09, 0x3b, 0xaa, 0xa6, 0xed, 0x68, 0xd2, 0xaa, 0xf2,
+	0x1a, 0xcc, 0xf7, 0x3d, 0x6c, 0x04, 0xd8, 0xbc, 0x75, 0xb0, 0x1e, 0x0e, 0xf1, 0xcc, 0x48, 0x36,
+	0x84, 0x6e, 0x47, 0xed, 0x1c, 0x26, 0xe5, 0x3a, 0x95, 0xb2, 0xbc, 0xac, 0xe2, 0xb2, 0x61, 0x42,
+	0x16, 0xee, 0x99, 0x7e, 0xa5, 0xeb, 0xd9, 0xc6, 0xb1, 0xea, 0xd9, 0x0b, 0x50, 0x13, 0xa1, 0x95,
+	0x98, 0x7b, 0x93, 0x79, 0x3e, 0xe1, 0x0b, 0x4c, 0x3f, 0xe1, 0x0c, 0x66, 0x93, 0xfd, 0xd0, 0x74,
+	0x51, 0xaa, 0x66, 0x8a, 0x52, 0xed, 0xa7, 0x45, 0x68, 0x46, 0xc5, 0xca, 0xc4, 0xde, 0x62, 0x92,
+	0x0b, 0xf2, 0x6d, 0x50, 0xa3, 0x78, 0x4c, 0x19, 0x79, 0x68, 0xbd, 0x95, 0xbe, 0x4b, 0x98, 0x1d,
+	0xa5, 0xcc, 0x32, 0xd1, 0xad, 0x2d, 0x3d, 0x57, 0xb7, 0xf6, 0x84, 0x17, 0x75, 0xd7, 0xe1, 0x74,
+	0x18, 0x67, 0x13, 0xc7, 0x66, 0xc9, 0xfc, 0x29, 0x31, 0xb8, 0x13, 0x3f, 0x7e, 0x8e, 0xa5, 0xcf,
+	0xe4, 0x59, 0x7a, 0x5a, 0xd2, 0x95, 0x8c, 0xa4, 0xb3, 0xf7, 0x85, 0x55, 0xc9, 0x7d, 0xa1, 0xf6,
+	0x00, 0xe6, 0x69, 0x8b, 0xce, 0xef, 0x7b, 0x56, 0x0f, 0x87, 0xa9, 0xe9, 0x24, 0x62, 0x6d, 0x43,
+	0x25, 0x95, 0xdd, 0x86, 0xdf, 0xda, 0x97, 0x0a, 0x2c, 0x64, 0xf7, 0xa5, 0x1a, 0x13, 0xf9, 0x0b,
+	0x25, 0xe1, 0x2f, 0xfe, 0x0c, 0xe6, 0xa3, 0xed, 0x93, 0x79, 0x73, 0x4e, 0x66, 0x28, 0x21, 0x5c,
+	0x47, 0xd1, 0x1e, 0x02, 0xa6, 0xfd, 0x5a, 0x09, 0x3b, 0x9d, 0x04, 0x36, 0xa0, 0x5d, 0x5e, 0x12,
+	0xc3, 0x5c, 0xc7, 0xb6, 0x9c, 0xb0, 0xb8, 0xe6, 0x67, 0x64, 0x40, 0x5e, 0x5c, 0x7f, 0x02, 0xb3,
+	0x7c, 0x52, 0x18, 0x8a, 0x26, 0x4c, 0xbe, 0x9a, 0x6c, 0x5d, 0x18, 0x84, 0x2e, 0x43, 0x93, 0xb7,
+	0x5f, 0x05, 0xbe, 0xa2, 0xa4, 0x29, 0x8b, 0xfe, 0x18, 0x54, 0x31, 0xed, 0x79, 0x83, 0xdf, 0x2c,
+	0x5f, 0x18, 0x26, 0x71, 0x7f, 0xa5, 0x40, 0x2b, 0x19, 0x0a, 0x63, 0xc7, 0x7f, 0xfe, 0x54, 0xee,
+	0xfd, 0xe4, 0xc5, 0xd5, 0xe5, 0x43, 0xe8, 0x89, 0xf0, 0x88, 0xeb, 0xab, 0x6d, 0x7a, 0x09, 0x49,
+	0x2a, 0x90, 0x0d, 0xcb, 0x0f, 0x3c, 0xab, 0x37, 0x3e, 0xd1, 0x0b, 0x0a, 0xed, 0x7f, 0x0a, 0xf0,
+	0xaa, 0x74, 0xc3, 0x93, 0x5c, 0x51, 0xe5, 0x15, 0xfc, 0xb7, 0xa0, 0x92, 0xaa, 0x54, 0xae, 0x1c,
+	0x72, 0x78, 0xde, 0xbb, 0x62, 0x3d, 0x14, 0xb1, 0x8e, 0xec, 0x11, 0xea, 0x74, 0x29, 0x7f, 0x0f,
+	0xae, 0xb4, 0x89, 0x3d, 0xc4, 0x3a, 0x74, 0x13, 0xea, 0xac, 0x0a, 0xec, 0xee, 0x5b, 0xf8, 0xa9,
+	0xb8, 0x59, 0x39, 0x2f, 0xf5, 0x6b, 0x74, 0xde, 0x43, 0x0b, 0x3f, 0xd5, 0x6b, 0x76, 0xf8, 0xdb,
+	0xd7, 0xfe, 0xa3, 0x00, 0x10, 0x8d, 0x91, 0x12, 0x34, 0x32, 0x18, 0x6e, 0x01, 0x31, 0x08, 0x89,
+	0xb7, 0xc9, 0x14, 0x4f, 0x7c, 0x22, 0x3d, 0x6a, 0x9d, 0x9a, 0x96, 0x1f, 0x70, 0xbe, 0xac, 0x1e,
+	0x4e, 0x8b, 0x60, 0x11, 0x11, 0x19, 0xbb, 0xb8, 0x10, 0x25, 0x16, 0x81, 0xa0, 0x37, 0x01, 0x0d,
+	0x3c, 0xf7, 0xa9, 0xe5, 0x0c, 0xe2, 0x89, 0x39, 0xcb, 0xdf, 0xe7, 0xf8, 0x48, 0x94, 0x99, 0xb7,
+	0xbb, 0xa0, 0xa6, 0xf7, 0x93, 0xdc, 0x5f, 0xbc, 0x93, 0xbc, 0xbf, 0x38, 0xcc, 0x8c, 0xc8, 0x36,
+	0xf1, 0x0b, 0x8c, 0x8f, 0xc2, 0x6c, 0x8a, 0x92, 0x97, 0xe7, 0xb9, 0x62, 0x3d, 0xab, 0x42, 0xa2,
+	0x67, 0xa5, 0xfd, 0x83, 0x02, 0x28, 0xab, 0x15, 0xa8, 0x09, 0x85, 0x70, 0x93, 0xc2, 0xd6, 0x46,
+	0x4a, 0x0a, 0x85, 0x8c, 0x14, 0xce, 0x42, 0x35, 0x8c, 0x24, 0xdc, 0x6d, 0x44, 0x80, 0xb8, 0x8c,
+	0x4a, 0x49, 0x19, 0xc5, 0x08, 0x2b, 0x27, 0x09, 0xdb, 0x03, 0x94, 0xd5, 0xb4, 0xf8, 0x4e, 0x4a,
+	0x72, 0xa7, 0xa3, 0x28, 0x8c, 0x61, 0x2a, 0x26, 0x31, 0xfd, 0x58, 0x01, 0x14, 0xc5, 0xca, 0xf0,
+	0x72, 0x65, 0x92, 0x00, 0xb3, 0x0a, 0xf3, 0xd9, 0x48, 0x2a, 0xd2, 0x07, 0x94, 0x89, 0xa3, 0xb2,
+	0x98, 0x57, 0x94, 0xbd, 0x91, 0x79, 0x37, 0xf4, 0x0d, 0x2c, 0x31, 0x38, 0x9f, 0x97, 0x18, 0x24,
+	0xdd, 0x83, 0xf6, 0xbf, 0x0a, 0xcc, 0x85, 0xd8, 0x9e, 0xeb, 0x24, 0x47, 0x5f, 0x16, 0xbd, 0x64,
+	0xd2, 0x3b, 0x30, 0xc3, 0xdb, 0x23, 0x19, 0xe5, 0x9b, 0xa4, 0x0a, 0x38, 0x05, 0x65, 0xa2, 0xeb,
+	0xa2, 0x5f, 0xc0, 0x3e, 0xb4, 0xff, 0x52, 0x00, 0x3a, 0x07, 0x4e, 0xff, 0x26, 0xd3, 0x81, 0x6b,
+	0x50, 0x3a, 0xea, 0x6e, 0x9c, 0xcc, 0xa6, 0xd9, 0x16, 0x9d, 0x39, 0x01, 0x5b, 0x12, 0x05, 0x4c,
+	0x31, 0x5d, 0xc0, 0xe4, 0x95, 0x1e, 0xf9, 0x7a, 0xff, 0x43, 0x05, 0xce, 0x10, 0x22, 0x5e, 0x48,
+	0x10, 0x9a, 0x88, 0x75, 0x31, 0x9b, 0x2a, 0x26, 0x6d, 0xea, 0x06, 0xcc, 0xb0, 0x1a, 0x42, 0x04,
+	0x84, 0xf3, 0x79, 0x2c, 0x63, 0x0c, 0xd6, 0xc5, 0xf4, 0xe5, 0x3f, 0x82, 0x6a, 0xd8, 0xcb, 0x43,
+	0x35, 0x98, 0x79, 0xe0, 0xdc, 0x71, 0xdc, 0xa7, 0x8e, 0x3a, 0x85, 0x66, 0xa0, 0x78, 0xd3, 0xb6,
+	0x55, 0x05, 0x35, 0xa0, 0xda, 0x09, 0x3c, 0x6c, 0x0c, 0x2d, 0x67, 0xa0, 0x16, 0x50, 0x13, 0xe0,
+	0x13, 0xcb, 0x0f, 0x5c, 0xcf, 0xea, 0x1b, 0xb6, 0x5a, 0x5c, 0xfe, 0x02, 0x9a, 0xc9, 0x14, 0x1a,
+	0xd5, 0xa1, 0xb2, 0xed, 0x06, 0x1f, 0x3f, 0xb3, 0xfc, 0x40, 0x9d, 0x22, 0xf3, 0xb7, 0xdd, 0x60,
+	0xc7, 0xc3, 0x3e, 0x76, 0x02, 0x55, 0x41, 0x00, 0xd3, 0x9f, 0x3a, 0x1b, 0x96, 0xff, 0x58, 0x2d,
+	0xa0, 0x79, 0x5e, 0x04, 0x1b, 0xf6, 0x16, 0xcf, 0x4b, 0xd5, 0x22, 0x59, 0x1e, 0x7e, 0x95, 0x90,
+	0x0a, 0xf5, 0x70, 0xca, 0xe6, 0xce, 0x03, 0xb5, 0x8c, 0xaa, 0x50, 0x66, 0x3f, 0xa7, 0x97, 0x4d,
+	0x50, 0xd3, 0x1d, 0x1c, 0xb2, 0x27, 0x3b, 0x44, 0x08, 0x52, 0xa7, 0xc8, 0xc9, 0x78, 0x0b, 0x4d,
+	0x55, 0xd0, 0x2c, 0xd4, 0x62, 0x0d, 0x29, 0xb5, 0x40, 0x00, 0x9b, 0xde, 0xa8, 0xcf, 0xa5, 0xc7,
+	0x48, 0x20, 0x49, 0xd4, 0x06, 0xe1, 0x44, 0x69, 0xf9, 0x16, 0x54, 0x44, 0x6e, 0x4f, 0xa6, 0x72,
+	0x16, 0x91, 0x4f, 0x75, 0x0a, 0xcd, 0x41, 0x23, 0xf1, 0xf8, 0x4d, 0x55, 0x10, 0x82, 0x66, 0xf2,
+	0x6d, 0xa9, 0x5a, 0x58, 0x5e, 0x03, 0x88, 0x6c, 0x89, 0x90, 0xb3, 0xe5, 0xec, 0x1b, 0xb6, 0x65,
+	0x32, 0xda, 0xc8, 0x10, 0xe1, 0x2e, 0xe5, 0x0e, 0x6b, 0xc5, 0xa8, 0x85, 0xe5, 0x0b, 0x50, 0x11,
+	0x5a, 0x4e, 0xe0, 0x3a, 0x1e, 0xba, 0xfb, 0x98, 0x49, 0xa6, 0x83, 0x03, 0x55, 0x59, 0xfb, 0xc7,
+	0x06, 0x00, 0x6b, 0xba, 0xb8, 0xae, 0x67, 0x22, 0x1b, 0xd0, 0x26, 0x0e, 0x48, 0x41, 0xe9, 0x3a,
+	0xa2, 0x18, 0xf4, 0xd1, 0x4a, 0x52, 0x15, 0xf8, 0x47, 0x76, 0x22, 0x3f, 0x7d, 0xfb, 0x92, 0x74,
+	0x7e, 0x6a, 0xb2, 0x36, 0x85, 0x86, 0x14, 0xdb, 0x7d, 0x6b, 0x88, 0xef, 0x5b, 0xfd, 0xc7, 0x61,
+	0xa7, 0x26, 0xff, 0x61, 0x68, 0x6a, 0xaa, 0xc0, 0x77, 0x51, 0x8a, 0xaf, 0x13, 0x78, 0x96, 0x33,
+	0x10, 0x39, 0x98, 0x36, 0x85, 0x9e, 0xa4, 0x9e, 0xa5, 0x0a, 0x84, 0x6b, 0x93, 0xbc, 0x44, 0x3d,
+	0x1e, 0x4a, 0x1b, 0x66, 0x53, 0xcf, 0xec, 0xd1, 0xb2, 0xfc, 0xa5, 0x91, 0xec, 0x2f, 0x01, 0xed,
+	0xab, 0x13, 0xcd, 0x0d, 0xb1, 0x59, 0xd0, 0x4c, 0x3e, 0x25, 0x47, 0x7f, 0x90, 0xb7, 0x41, 0xe6,
+	0xad, 0x63, 0x7b, 0x79, 0x92, 0xa9, 0x21, 0xaa, 0x47, 0x4c, 0x41, 0x8f, 0x42, 0x25, 0x7d, 0xd4,
+	0xd9, 0x3e, 0x2c, 0xfd, 0xd5, 0xa6, 0xd0, 0xe7, 0x30, 0x97, 0x79, 0x91, 0x89, 0xde, 0x90, 0x77,
+	0xe3, 0xe5, 0x0f, 0x37, 0x8f, 0xc2, 0xf0, 0x28, 0x6d, 0x5e, 0xf9, 0xd4, 0x67, 0x1e, 0x58, 0x4f,
+	0x4e, 0x7d, 0x6c, 0xfb, 0xc3, 0xa8, 0x7f, 0x6e, 0x0c, 0x63, 0x6a, 0x36, 0xe9, 0xd6, 0xdf, 0x9b,
+	0x32, 0x14, 0xb9, 0xcf, 0x42, 0xdb, 0x2b, 0x93, 0x4e, 0x8f, 0x6b, 0x57, 0xf2, 0xe5, 0xa1, 0x9c,
+	0x69, 0xd2, 0xd7, 0x92, 0x72, 0xed, 0x92, 0x3f, 0x64, 0xd4, 0xa6, 0xd0, 0xfd, 0x84, 0x7b, 0x45,
+	0x57, 0xf2, 0x84, 0x93, 0xbc, 0x10, 0x38, 0x8a, 0x6f, 0x7f, 0x01, 0x88, 0xd9, 0x8e, 0xb3, 0x6b,
+	0x0d, 0xc6, 0x9e, 0xc1, 0x14, 0x2b, 0xcf, 0xdd, 0x64, 0xa7, 0x0a, 0x34, 0x6f, 0x3d, 0xc7, 0x8a,
+	0xf0, 0x48, 0x5d, 0x80, 0x4d, 0x1c, 0xdc, 0xc3, 0x81, 0x67, 0xf5, 0xfd, 0xf4, 0x89, 0x22, 0x8f,
+	0xca, 0x27, 0x08, 0x54, 0xaf, 0x1f, 0x39, 0x2f, 0x44, 0xd0, 0x83, 0xda, 0x26, 0x0e, 0x78, 0x5e,
+	0xe5, 0xa3, 0xdc, 0x95, 0x62, 0x86, 0x40, 0xb1, 0x74, 0xf4, 0xc4, 0xb8, 0x3b, 0x4b, 0xbd, 0xc2,
+	0x44, 0xb9, 0x82, 0xcd, 0xbe, 0x0d, 0x95, 0xbb, 0xb3, 0x9c, 0x67, 0x9d, 0xda, 0xd4, 0xda, 0xd7,
+	0x4d, 0xa8, 0xd2, 0xd8, 0x44, 0x02, 0xe9, 0xef, 0x43, 0xd3, 0x0b, 0x0e, 0x4d, 0x9f, 0xc1, 0x6c,
+	0xea, 0x41, 0x9f, 0x5c, 0x96, 0xf2, 0x57, 0x7f, 0x13, 0x78, 0xd8, 0xe4, 0x63, 0x3b, 0xb9, 0xb3,
+	0x90, 0x3e, 0xc8, 0x3b, 0x6a, 0xef, 0x87, 0xec, 0x2d, 0x6c, 0xd8, 0xcc, 0x7a, 0x3d, 0xb7, 0xec,
+	0x48, 0xde, 0x75, 0x7e, 0xfb, 0x9e, 0xfb, 0xe5, 0x47, 0xb6, 0xcf, 0x60, 0x36, 0xf5, 0xe2, 0x44,
+	0x2e, 0x55, 0xf9, 0xb3, 0x94, 0xa3, 0x76, 0xff, 0x06, 0x43, 0x80, 0x09, 0xf3, 0x92, 0xc7, 0x00,
+	0x68, 0x25, 0xaf, 0x2a, 0x91, 0xbf, 0x1a, 0x38, 0xfa, 0x40, 0x8d, 0x84, 0x29, 0xa1, 0xa5, 0x3c,
+	0x22, 0xd3, 0x7f, 0x49, 0x6a, 0xbf, 0x31, 0xd9, 0xff, 0x97, 0xc2, 0x03, 0x75, 0x60, 0x9a, 0xbd,
+	0x43, 0x41, 0xaf, 0xc9, 0x9b, 0x3e, 0xb1, 0x37, 0x2a, 0xed, 0xa3, 0x5e, 0xb2, 0xf8, 0x63, 0x3b,
+	0xf0, 0xe9, 0xa6, 0x65, 0xea, 0x21, 0x91, 0xf4, 0x01, 0x55, 0xfc, 0xf1, 0x48, 0xfb, 0xe8, 0xf7,
+	0x22, 0x62, 0xd3, 0xdf, 0xed, 0x38, 0xf9, 0x0c, 0xe6, 0x25, 0xad, 0x5a, 0x94, 0x97, 0x0f, 0xe5,
+	0x34, 0x89, 0xdb, 0xab, 0x13, 0xcf, 0x0f, 0x31, 0xff, 0x39, 0xa8, 0xe9, 0x6a, 0x1f, 0x5d, 0xcd,
+	0xd3, 0x67, 0x19, 0xce, 0xc3, 0x95, 0xf9, 0xd6, 0xdb, 0x8f, 0xd6, 0x06, 0x56, 0xb0, 0x37, 0xee,
+	0x91, 0x91, 0x55, 0x36, 0xf5, 0x4d, 0xcb, 0xe5, 0xbf, 0x56, 0x05, 0xff, 0x57, 0xe9, 0xea, 0x55,
+	0x8a, 0x6a, 0xd4, 0xeb, 0x4d, 0xd3, 0xcf, 0xeb, 0xbf, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xb2, 0xc0,
+	0x8c, 0xd2, 0x0d, 0x3d, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

internal/proxy/impl.go

@@ -430,6 +430,7 @@ func (node *Proxy) LoadCollection(ctx context.Context, request *milvuspb.LoadCol
 		Condition:             NewTaskCondition(ctx),
 		LoadCollectionRequest: request,
 		queryCoord:            node.queryCoord,
+		indexCoord:            node.indexCoord,
 	}
 
 	log.Debug("LoadCollection received",
@@ -1395,6 +1396,7 @@ func (node *Proxy) LoadPartitions(ctx context.Context, request *milvuspb.LoadPar
 		Condition:             NewTaskCondition(ctx),
 		LoadPartitionsRequest: request,
 		queryCoord:            node.queryCoord,
+		indexCoord:            node.indexCoord,
 	}
 
 	log.Debug(

internal/proxy/index_coord_mock_test.go

@@ -240,10 +240,12 @@ func NewIndexCoordMock() *IndexCoordMock {
 }
 
 type GetIndexStateFunc func(ctx context.Context, request *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)
+type DescribeIndexFunc func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)
 
 type mockIndexCoord struct {
 	types.IndexCoord
 	GetIndexStateFunc
+	DescribeIndexFunc
 }
 
 func (m *mockIndexCoord) GetIndexState(ctx context.Context, request *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) {
@@ -255,6 +257,15 @@ func (m *mockIndexCoord) GetIndexState(ctx context.Context, request *indexpb.Get
 	return nil, errors.New("mock")
 }
 
+func (m *mockIndexCoord) DescribeIndex(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+	if m.DescribeIndexFunc != nil {
+		log.Warn("DescribeIndexFunc not nil")
+		return m.DescribeIndexFunc(ctx, request)
+	}
+	log.Warn("DescribeIndexFunc nil")
+	return nil, errors.New("mock")
+}
+
 func newMockIndexCoord() *mockIndexCoord {
 	return &mockIndexCoord{}
 }

internal/proxy/rootcoord_mock_test.go

@@ -1126,7 +1126,6 @@ func (coord *RootCoordMock) AlterCollection(ctx context.Context, request *milvus
 
 type DescribeCollectionFunc func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
 type ShowPartitionsFunc func(ctx context.Context, request *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)
-type DescribeIndexFunc func(ctx context.Context, request *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error)
 type ShowSegmentsFunc func(ctx context.Context, request *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)
 type DescribeSegmentsFunc func(ctx context.Context, request *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error)
 type ImportFunc func(ctx context.Context, req *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error)
@@ -1138,7 +1137,6 @@ type mockRootCoord struct {
 	types.RootCoord
 	DescribeCollectionFunc
 	ShowPartitionsFunc
-	DescribeIndexFunc
 	ShowSegmentsFunc
 	DescribeSegmentsFunc
 	ImportFunc

internal/proxy/task.go

@@ -26,20 +26,19 @@ import (
 	"github.com/golang/protobuf/proto"
 	"go.uber.org/zap"
 
+	"github.com/milvus-io/milvus-proto/go-api/commonpb"
+	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
+	"github.com/milvus-io/milvus-proto/go-api/schemapb"
 	"github.com/milvus-io/milvus/internal/common"
 	"github.com/milvus-io/milvus/internal/log"
 	"github.com/milvus-io/milvus/internal/metrics"
 	"github.com/milvus-io/milvus/internal/mq/msgstream"
-	"github.com/milvus-io/milvus/internal/types"
-
-	"github.com/milvus-io/milvus-proto/go-api/commonpb"
-	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
-	"github.com/milvus-io/milvus-proto/go-api/schemapb"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/proto/planpb"
 	"github.com/milvus-io/milvus/internal/proto/querypb"
-
+	"github.com/milvus-io/milvus/internal/types"
 	"github.com/milvus-io/milvus/internal/util/timerecord"
 	"github.com/milvus-io/milvus/internal/util/trace"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
@@ -1226,6 +1225,7 @@ type loadCollectionTask struct {
 	*milvuspb.LoadCollectionRequest
 	ctx        context.Context
 	queryCoord types.QueryCoord
+	indexCoord types.IndexCoord
 	result     *commonpb.Status
 
 	collectionID UniqueID
@@ -1299,6 +1299,33 @@ func (lct *loadCollectionTask) Execute(ctx context.Context) (err error) {
 	if err != nil {
 		return err
 	}
+	// check index
+	indexResponse, err := lct.indexCoord.DescribeIndex(ctx, &indexpb.DescribeIndexRequest{
+		CollectionID: collID,
+		IndexName:    "",
+	})
+	if err != nil {
+		return err
+	}
+	if indexResponse.Status.ErrorCode != commonpb.ErrorCode_Success {
+		return errors.New(indexResponse.Status.Reason)
+	}
+
+	hasVecIndex := false
+	fieldIndexIDs := make(map[int64]int64)
+	for _, index := range indexResponse.IndexInfos {
+		fieldIndexIDs[index.FieldID] = index.IndexID
+		for _, field := range collSchema.Fields {
+			if index.FieldID == field.FieldID && (field.DataType == schemapb.DataType_FloatVector || field.DataType == schemapb.DataType_BinaryVector) {
+				hasVecIndex = true
+			}
+		}
+	}
+	if !hasVecIndex {
+		errMsg := fmt.Sprintf("there is no vector index on collection: %s, please create index firstly", lct.LoadCollectionRequest.CollectionName)
+		log.Ctx(ctx).Error(errMsg)
+		return errors.New(errMsg)
+	}
 	request := &querypb.LoadCollectionRequest{
 		Base: &commonpb.MsgBase{
 			MsgType:   commonpb.MsgType_LoadCollection,
@@ -1310,6 +1337,7 @@ func (lct *loadCollectionTask) Execute(ctx context.Context) (err error) {
 		CollectionID:  collID,
 		Schema:        collSchema,
 		ReplicaNumber: lct.ReplicaNumber,
+		FieldIndexID:  fieldIndexIDs,
 	}
 	log.Debug("send LoadCollectionRequest to query coordinator", zap.String("role", typeutil.ProxyRole),
 		zap.Int64("msgID", request.Base.MsgID), zap.Int64("collectionID", request.CollectionID),
@@ -1422,6 +1450,7 @@ type loadPartitionsTask struct {
 	*milvuspb.LoadPartitionsRequest
 	ctx        context.Context
 	queryCoord types.QueryCoord
+	indexCoord types.IndexCoord
 	result     *commonpb.Status
 
 	collectionID UniqueID
@@ -1488,6 +1517,33 @@ func (lpt *loadPartitionsTask) Execute(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
+	// check index
+	indexResponse, err := lpt.indexCoord.DescribeIndex(ctx, &indexpb.DescribeIndexRequest{
+		CollectionID: collID,
+		IndexName:    "",
+	})
+	if err != nil {
+		return err
+	}
+	if indexResponse.Status.ErrorCode != commonpb.ErrorCode_Success {
+		return errors.New(indexResponse.Status.Reason)
+	}
+
+	hasVecIndex := false
+	fieldIndexIDs := make(map[int64]int64)
+	for _, index := range indexResponse.IndexInfos {
+		fieldIndexIDs[index.FieldID] = index.IndexID
+		for _, field := range collSchema.Fields {
+			if index.FieldID == field.FieldID && (field.DataType == schemapb.DataType_FloatVector || field.DataType == schemapb.DataType_BinaryVector) {
+				hasVecIndex = true
+			}
+		}
+	}
+	if !hasVecIndex {
+		errMsg := fmt.Sprintf("there is no vector index on collection: %s, please create index firstly", lpt.LoadPartitionsRequest.CollectionName)
+		log.Ctx(ctx).Error(errMsg)
+		return errors.New(errMsg)
+	}
 	for _, partitionName := range lpt.PartitionNames {
 		partitionID, err := globalMetaCache.GetPartitionID(ctx, lpt.CollectionName, partitionName)
 		if err != nil {
@@ -1507,6 +1563,7 @@ func (lpt *loadPartitionsTask) Execute(ctx context.Context) error {
 		PartitionIDs:  partitionIDs,
 		Schema:        collSchema,
 		ReplicaNumber: lpt.ReplicaNumber,
+		FieldIndexID:  fieldIndexIDs,
 	}
 	lpt.result, err = lpt.queryCoord.LoadPartitions(ctx, request)
 	return err

internal/proxy/task_index.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 
 	"go.uber.org/zap"
 
@@ -290,7 +291,7 @@ func (cit *createIndexTask) Execute(ctx context.Context) error {
 		zap.Any("indexParams", cit.req.GetExtraParams()))
 
 	if cit.req.GetIndexName() == "" {
-		cit.req.IndexName = Params.CommonCfg.DefaultIndexName
+		cit.req.IndexName = Params.CommonCfg.DefaultIndexName + "_" + strconv.FormatInt(cit.fieldSchema.GetFieldID(), 10)
 	}
 	var err error
 	req := &indexpb.CreateIndexRequest{

internal/proxy/task_test.go

@@ -27,6 +27,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
+
 	"github.com/milvus-io/milvus/internal/mocks"
 	"github.com/stretchr/testify/mock"
 
@@ -2203,3 +2205,197 @@ func Test_dropCollectionTask_PostExecute(t *testing.T) {
 	dct := &dropCollectionTask{}
 	assert.NoError(t, dct.PostExecute(context.Background()))
 }
+
+func Test_loadCollectionTask_Execute(t *testing.T) {
+	rc := newMockRootCoord()
+	qc := NewQueryCoordMock(withValidShardLeaders())
+	ic := newMockIndexCoord()
+
+	dbName := funcutil.GenRandomStr()
+	collectionName := funcutil.GenRandomStr()
+	collectionID := UniqueID(1)
+	//fieldName := funcutil.GenRandomStr()
+	indexName := funcutil.GenRandomStr()
+	ctx := context.Background()
+	indexID := int64(1000)
+
+	shardMgr := newShardClientMgr()
+	// failed to get collection id.
+	_ = InitMetaCache(ctx, rc, qc, shardMgr)
+
+	rc.DescribeCollectionFunc = func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
+		return &milvuspb.DescribeCollectionResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_Success,
+			},
+			Schema:         newTestSchema(),
+			CollectionID:   collectionID,
+			CollectionName: request.CollectionName,
+		}, nil
+	}
+
+	lct := &loadCollectionTask{
+		LoadCollectionRequest: &milvuspb.LoadCollectionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   commonpb.MsgType_LoadCollection,
+				MsgID:     1,
+				Timestamp: 1,
+				SourceID:  1,
+				TargetID:  1,
+			},
+			DbName:         dbName,
+			CollectionName: collectionName,
+			ReplicaNumber:  1,
+		},
+		ctx:          ctx,
+		queryCoord:   qc,
+		indexCoord:   ic,
+		result:       nil,
+		collectionID: 0,
+	}
+
+	t.Run("indexcoord describe index error", func(t *testing.T) {
+		err := lct.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("indexcoord describe index not success", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_UnexpectedError,
+					Reason:    "fail reason",
+				},
+			}, nil
+		}
+
+		err := lct.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("no vector index", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_Success,
+				},
+				IndexInfos: []*indexpb.IndexInfo{
+					{
+						CollectionID:         collectionID,
+						FieldID:              100,
+						IndexName:            indexName,
+						IndexID:              indexID,
+						TypeParams:           nil,
+						IndexParams:          nil,
+						IndexedRows:          1025,
+						TotalRows:            1025,
+						State:                commonpb.IndexState_Finished,
+						IndexStateFailReason: "",
+						IsAutoIndex:          false,
+						UserIndexParams:      nil,
+					},
+				},
+			}, nil
+		}
+
+		err := lct.Execute(ctx)
+		assert.Error(t, err)
+	})
+}
+
+func Test_loadPartitionTask_Execute(t *testing.T) {
+	rc := newMockRootCoord()
+	qc := NewQueryCoordMock(withValidShardLeaders())
+	ic := newMockIndexCoord()
+
+	dbName := funcutil.GenRandomStr()
+	collectionName := funcutil.GenRandomStr()
+	collectionID := UniqueID(1)
+	//fieldName := funcutil.GenRandomStr()
+	indexName := funcutil.GenRandomStr()
+	ctx := context.Background()
+	indexID := int64(1000)
+
+	shardMgr := newShardClientMgr()
+	// failed to get collection id.
+	_ = InitMetaCache(ctx, rc, qc, shardMgr)
+
+	rc.DescribeCollectionFunc = func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
+		return &milvuspb.DescribeCollectionResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_Success,
+			},
+			Schema:         newTestSchema(),
+			CollectionID:   collectionID,
+			CollectionName: request.CollectionName,
+		}, nil
+	}
+
+	lpt := &loadPartitionsTask{
+		LoadPartitionsRequest: &milvuspb.LoadPartitionsRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   commonpb.MsgType_LoadCollection,
+				MsgID:     1,
+				Timestamp: 1,
+				SourceID:  1,
+				TargetID:  1,
+			},
+			DbName:         dbName,
+			CollectionName: collectionName,
+			ReplicaNumber:  1,
+		},
+		ctx:          ctx,
+		queryCoord:   qc,
+		indexCoord:   ic,
+		result:       nil,
+		collectionID: 0,
+	}
+
+	t.Run("indexcoord describe index error", func(t *testing.T) {
+		err := lpt.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("indexcoord describe index not success", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_UnexpectedError,
+					Reason:    "fail reason",
+				},
+			}, nil
+		}
+
+		err := lpt.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("no vector index", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_Success,
+				},
+				IndexInfos: []*indexpb.IndexInfo{
+					{
+						CollectionID:         collectionID,
+						FieldID:              100,
+						IndexName:            indexName,
+						IndexID:              indexID,
+						TypeParams:           nil,
+						IndexParams:          nil,
+						IndexedRows:          1025,
+						TotalRows:            1025,
+						State:                commonpb.IndexState_Finished,
+						IndexStateFailReason: "",
+						IsAutoIndex:          false,
+						UserIndexParams:      nil,
+					},
+				},
+			}, nil
+		}
+
+		err := lpt.Execute(ctx)
+		assert.Error(t, err)
+	})
+}

tests/python_client/base/client_base.py

@@ -169,7 +169,16 @@ class TestcaseBase(Base):
                 assert collection_w.num_entities == nb
             # This condition will be removed after auto index feature
             if not is_index:
+                if is_binary:
+                    collection_w.create_index(ct.default_binary_vec_field_name, ct.default_bin_flat_index)
+                else:
+                    collection_w.create_index(ct.default_float_vec_field_name, ct.default_flat_index)
                 collection_w.load()
+        elif not is_index:
+            if is_binary:
+                collection_w.create_index(ct.default_binary_vec_field_name, ct.default_bin_flat_index)
+            else:
+                collection_w.create_index(ct.default_float_vec_field_name, ct.default_flat_index)
 
         return collection_w, vectors, binary_raw_vectors, insert_ids, time_stamp
 
@@ -190,6 +199,7 @@ class TestcaseBase(Base):
         collection_w.insert(df_default)
         # flush
         collection_w.num_entities
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(partition_names=[partition_w.name, "_default"])
         return collection_w, partition_w, df_partition, df_default
 

tests/python_client/common/common_type.py

@@ -70,6 +70,9 @@ err_code = "err_code"
 err_msg = "err_msg"
 in_cluster_env = "IN_CLUSTER"
 
+default_flat_index = {"index_type": "FLAT", "params": {}, "metric_type": "L2"}
+default_bin_flat_index = {"index_type": "BIN_FLAT", "params": {}, "metric_type": "JACCARD"}
+
 """" List of parameters used to pass """
 get_invalid_strs = [
     [],

tests/python_client/requirements.txt

@@ -9,7 +9,7 @@ allure-pytest==2.7.0
 pytest-print==0.2.1
 pytest-level==0.1.1
 pytest-xdist==2.5.0
-pymilvus==2.2.0.dev44
+pymilvus==2.2.0.dev45
 pytest-rerunfailures==9.1.1
 git+https://github.com/Projectplace/pytest-tags
 ndg-httpsclient

tests/python_client/testcases/test_collection.py

@@ -1114,6 +1114,7 @@ class TestCollectionOperation(TestcaseBase):
         collection_w = self.init_collection_wrap()
         partition_w1 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         error = {ct.err_code: 5, ct.err_msg: f'load the partition after load collection is not supported'}
         partition_w1.load(check_task=CheckTasks.err_res,
@@ -1130,6 +1131,7 @@ class TestCollectionOperation(TestcaseBase):
         collection_w = self.init_collection_wrap()
         partition_w1 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         error = {ct.err_code: 1, ct.err_msg: f'releasing the partition after load collection is not supported'}
         partition_w1.release(check_task=CheckTasks.err_res,
@@ -1147,6 +1149,7 @@ class TestCollectionOperation(TestcaseBase):
         collection_w = self.init_collection_wrap(name=c_name, check_task=CheckTasks.check_collection_property,
                                                  check_items={exp_name: c_name, exp_schema: default_schema})
         collection_w.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.release()
 
@@ -2036,6 +2039,7 @@ class TestLoadCollection(TestcaseBase):
         """
         self._connect()
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.release()
 
@@ -2126,6 +2130,7 @@ class TestLoadCollection(TestcaseBase):
         insert_data = cf.gen_default_list_data()
         collection_w.insert(data=insert_data)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.release()
         collection_w.load()
@@ -2142,6 +2147,7 @@ class TestLoadCollection(TestcaseBase):
         insert_data = cf.gen_default_list_data()
         collection_w.insert(data=insert_data)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.load()
 
@@ -2156,6 +2162,7 @@ class TestLoadCollection(TestcaseBase):
         self._connect()
         c_name = cf.gen_unique_str()
         collection_wr = self.init_collection_wrap(name=c_name)
+        collection_wr.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_wr.load()
         collection_wr.release()
         collection_wr.drop()
@@ -2174,6 +2181,7 @@ class TestLoadCollection(TestcaseBase):
         self._connect()
         c_name = cf.gen_unique_str()
         collection_wr = self.init_collection_wrap(name=c_name)
+        collection_wr.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_wr.load()
         collection_wr.drop()
         error = {ct.err_code: 0,
@@ -2193,6 +2201,7 @@ class TestLoadCollection(TestcaseBase):
         data = cf.gen_default_list_data()
         collection_w.insert(data=data, partition_name=ct.default_tag)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         patition_w.load()
         collection_w.release()
 
@@ -2216,6 +2225,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         insert_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # load with non-number replicas
         error = {ct.err_code: 0, ct.err_msg: f"but expected one of: int, long"}
@@ -2234,6 +2244,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         insert_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         collection_w.load(replica_number=replicas)
         replicas = collection_w.get_replicas()[0]
@@ -2253,6 +2264,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         insert_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         error = {ct.err_code: 1, ct.err_msg: f"no enough nodes to create replicas"}
         collection_w.load(replica_number=3, check_task=CheckTasks.err_res, check_items=error)
@@ -2326,6 +2338,7 @@ class TestLoadCollection(TestcaseBase):
             insert_res, _ = collection_w.insert(df)
             assert collection_w.num_entities == (i + 1) * tmp_nb
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(replica_number=replica_number)
         replicas = collection_w.get_replicas()[0]
         assert len(replicas.groups) == replica_number
@@ -2356,6 +2369,7 @@ class TestLoadCollection(TestcaseBase):
         partition_w = self.init_partition_wrap(collection_w, ct.default_tag)
         partition_w.insert(df_2)
         assert collection_w.num_entities == ct.default_nb * 2
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         collection_w.load([partition_w.name], replica_number=2)
         for seg in self.utility_wrap.get_query_segment_info(collection_w.name)[0]:
@@ -2390,6 +2404,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # load with multi replica and insert growing data
         collection_w.load(replica_number=2)
@@ -2439,6 +2454,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # load with multi replicas and insert growing data
         collection_w.load(replica_number=2)
@@ -2487,6 +2503,7 @@ class TestLoadCollection(TestcaseBase):
         mutation_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == 5000
         total_sq_count = 20
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         collection_w.load(replica_number=3)
         for i in range(total_sq_count):
@@ -2535,6 +2552,7 @@ class TestReleaseAdvanced(TestcaseBase):
         collection_wr = self.init_collection_wrap(name=c_name)
         collection_wr.insert(data=data)
         assert collection_wr.num_entities == ct.default_nb
+        collection_wr.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_wr.load()
         search_res, _ = collection_wr.search(vectors, default_search_field, default_search_params,
                                              default_limit, _async=True)
@@ -2553,6 +2571,7 @@ class TestReleaseAdvanced(TestcaseBase):
         self._connect()
         partition_num = 1
         collection_w = self.init_collection_general(prefix, True, 10, partition_num, is_index=True)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         par = collection_w.partitions
         par_name = par[partition_num].name
         par[partition_num].load()
@@ -2578,6 +2597,7 @@ class TestReleaseAdvanced(TestcaseBase):
         self._connect()
         partition_num = 1
         collection_w = self.init_collection_general(prefix, True, 10, partition_num, is_index=True)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         par = collection_w.partitions
         par_name = par[partition_num].name
         par[partition_num].load()
@@ -2640,6 +2660,7 @@ class TestLoadPartition(TestcaseBase):
                                                  'which does not match the index type: BIN_IVF_FLAT'}
             collection_w.create_index(ct.default_binary_vec_field_name, binary_index,
                                       check_task=CheckTasks.err_res, check_items=error)
+            collection_w.create_index(ct.default_binary_vec_field_name, ct.default_bin_flat_index)
         else:
             collection_w.create_index(ct.default_binary_vec_field_name, binary_index)
         par = collection_w.partitions
@@ -2662,6 +2683,7 @@ class TestLoadPartition(TestcaseBase):
                                                check_items={"name": partition_name, "description": description,
                                                             "is_empty": True, "num_entities": 0}
                                                )
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         self.connection_wrap.remove_connection(ct.default_alias)
         res_list, _ = self.connection_wrap.list_connections()
@@ -2686,6 +2708,7 @@ class TestLoadPartition(TestcaseBase):
                                                check_items={"name": partition_name, "description": description,
                                                             "is_empty": True, "num_entities": 0}
                                                )
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         self.connection_wrap.remove_connection(ct.default_alias)
         res_list, _ = self.connection_wrap.list_connections()
@@ -2710,6 +2733,7 @@ class TestLoadPartition(TestcaseBase):
                                                check_items={"name": partition_name, "description": description,
                                                             "is_empty": True, "num_entities": 0}
                                                )
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.drop()
         error = {ct.err_code: 0, ct.err_msg: 'partitionID of partitionName:%s can not be find' % partition_name}
         partition_w.load(check_task=CheckTasks.err_res, check_items=error)

tests/python_client/testcases/test_compaction.py

@@ -235,6 +235,7 @@ class TestCompactionParams(TestcaseBase):
         collection_w.insert(cf.gen_default_dataframe_data(1, start=tmp_nb))
         assert collection_w.num_entities == tmp_nb + 1
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(ratio_expr, check_items=CheckTasks.check_query_empty)
 
@@ -261,6 +262,7 @@ class TestCompactionParams(TestcaseBase):
         collection_w.delete(ratio_expr)
         assert collection_w.num_entities == tmp_nb
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(ratio_expr, check_task=CheckTasks.check_query_empty)
 
@@ -288,6 +290,7 @@ class TestCompactionParams(TestcaseBase):
         collection_w.wait_for_compaction_completed()
         collection_w.get_compaction_plans(check_task=CheckTasks.check_delete_compact)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(expr, check_items=CheckTasks.check_query_empty)
 

tests/python_client/testcases/test_delete.py

@@ -229,6 +229,7 @@ class TestDeleteParams(TestcaseBase):
         partition_w = self.init_partition_wrap(collection_wrap=collection_w)
 
         # load collection and insert data to partition
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         df = cf.gen_default_dataframe_data(tmp_nb)
         partition_w.insert(df)
@@ -320,7 +321,7 @@ class TestDeleteOperation(TestcaseBase):
         expected: assert index and deleted id not in search result
         """
         # create collection, insert tmp_nb, flush and load
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=True)[0:2]
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_index=True)[0:2]
 
         # create index
         index_params = {"index_type": "IVF_SQ8",
@@ -398,6 +399,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -470,6 +472,7 @@ class TestDeleteOperation(TestcaseBase):
         collection_w.insert(df)
         assert collection_w.num_entities == tmp_nb
         del_res, _ = collection_w.delete(tmp_expr)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # Just one query res and search res, because de-dup
@@ -554,6 +557,7 @@ class TestDeleteOperation(TestcaseBase):
         # delete same id 0 from default_partition, and query on it get empty result
         collection_w.delete(tmp_expr, partition_name=ct.default_partition_name)
         assert collection_w.num_entities == tmp_nb * 2
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, partition_names=[ct.default_partition_name],
                            check_task=CheckTasks.check_query_empty)
@@ -624,6 +628,7 @@ class TestDeleteOperation(TestcaseBase):
         assert del_res.delete_count == 1
 
         # load and query with id
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -640,6 +645,7 @@ class TestDeleteOperation(TestcaseBase):
         # create collection
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
         # load collection and the queryNode watch the insertChannel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # insert data
         df = cf.gen_default_dataframe_data(tmp_nb)
@@ -667,6 +673,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load collection and queryNode subscribe channel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # delete ids and query
@@ -700,6 +707,7 @@ class TestDeleteOperation(TestcaseBase):
         log.info(f'Collection num entities: {collection_w.num_entities}')
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -726,6 +734,7 @@ class TestDeleteOperation(TestcaseBase):
         collection_w.insert(cf.gen_default_dataframe_data(nb=1, start=tmp_nb))
         log.info(collection_w.num_entities)
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -750,6 +759,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -768,6 +778,7 @@ class TestDeleteOperation(TestcaseBase):
         """
         # init collection and insert data without flush
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         df = cf.gen_default_dataframe_data(tmp_nb)
         collection_w.insert(df)
@@ -815,6 +826,7 @@ class TestDeleteOperation(TestcaseBase):
         log.debug(collection_w.num_entities)
 
         # load and query
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res = df.iloc[:1, :1].to_dict('records')
         collection_w.search(data=[df[ct.default_float_vec_field_name][0]], anns_field=ct.default_float_vec_field_name,
@@ -905,6 +917,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -944,6 +957,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -1010,6 +1024,7 @@ class TestDeleteOperation(TestcaseBase):
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix))
         df = cf.gen_default_dataframe_data(tmp_nb)
         insert_res, _ = collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         tt = self.utility_wrap.mkts_from_hybridts(insert_res.timestamp, milliseconds=0.)
@@ -1051,6 +1066,7 @@ class TestDeleteOperation(TestcaseBase):
         expr = f'{ct.default_int64_field_name} in {ids}'
         collection_w.delete(expr)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(expr, check_task=CheckTasks.check_query_empty)
         search_res, _ = collection_w.search(cf.gen_vectors(ct.default_nq, ct.default_dim),
@@ -1082,6 +1098,7 @@ class TestDeleteOperation(TestcaseBase):
             assert collection_w.num_entities == (i + 1) * segment_per_count
             ids.extend(res.primary_keys)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         expr = f'{ct.default_int64_field_name} in {ids}'
@@ -1123,7 +1140,7 @@ class TestDeleteString(TestcaseBase):
         expected: assert index and deleted id not in search result
         """
         # create collection, insert tmp_nb, flush and load
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=True,
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_index=True,
                                                              primary_field=ct.default_string_field_name)[0:2]
 
         # create index
@@ -1209,6 +1226,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1286,6 +1304,7 @@ class TestDeleteString(TestcaseBase):
         collection_w.insert(df)
         assert collection_w.num_entities == tmp_nb
         del_res, _ = collection_w.delete(default_string_expr)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # Just one query res and search res, because de-dup
@@ -1321,6 +1340,7 @@ class TestDeleteString(TestcaseBase):
         collection_w.delete(default_string_expr,
                             partition_name=ct.default_partition_name)
         assert collection_w.num_entities == tmp_nb * 2
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr, partition_names=[ct.default_partition_name],
                            check_task=CheckTasks.check_query_empty)
@@ -1350,6 +1370,7 @@ class TestDeleteString(TestcaseBase):
         assert del_res.delete_count == 1
 
         # load and query with id
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1368,6 +1389,7 @@ class TestDeleteString(TestcaseBase):
         schema = cf.gen_string_pk_default_collection_schema()
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix), schema=schema)
         # load collection and the queryNode watch the insertChannel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # insert data
         df = cf.gen_default_dataframe_data(tmp_nb)
@@ -1397,6 +1419,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load collection and queryNode subscribe channel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # delete ids and query
@@ -1428,6 +1451,7 @@ class TestDeleteString(TestcaseBase):
         collection_w.insert(cf.gen_default_dataframe_data(nb=1, start=tmp_nb))
         log.info(collection_w.num_entities)
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1454,6 +1478,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1530,6 +1555,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1573,6 +1599,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1632,6 +1659,7 @@ class TestDeleteString(TestcaseBase):
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix), schema=schema)
         df = cf.gen_default_dataframe_data(tmp_nb)
         insert_res, _ = collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         tt = self.utility_wrap.mkts_from_hybridts(insert_res.timestamp, milliseconds=0.)
@@ -1676,6 +1704,7 @@ class TestDeleteString(TestcaseBase):
         expr = expr.replace("'", "\"")
         collection_w.delete(expr)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(expr, check_task=CheckTasks.check_query_empty)
         search_res, _ = collection_w.search(cf.gen_vectors(ct.default_nq, ct.default_dim),
@@ -1723,6 +1752,7 @@ class TestDeleteString(TestcaseBase):
         log.debug(collection_w.num_entities)
 
         # load and query
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res = df.iloc[:1, 2:3].to_dict('records')
         default_search_params = {"metric_type": "L2", "params": {"nprobe": 16}}
@@ -1766,6 +1796,7 @@ class TestDeleteString(TestcaseBase):
         df[2] = [""for _ in range(nb)] 
 
         collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         assert collection_w.num_entities == nb
 

tests/python_client/testcases/test_e2e.py

@@ -41,6 +41,10 @@ class TestE2e(TestcaseBase):
         log.info(f"assert flush: {tt}, entities: {entities}")
 
         # search
+        _index_params = {"index_type": "IVF_SQ8", "params": {"nlist": 64}, "metric_type": "L2"}
+        index, _ = collection_w.create_index(field_name=ct.default_float_vec_field_name,
+                                             index_params=_index_params,
+                                             name=cf.gen_unique_str())
         collection_w.load()
         search_vectors = cf.gen_vectors(1, ct.default_dim)
         search_params = {"metric_type": "L2", "params": {"nprobe": 16}}

tests/python_client/testcases/test_index.py

@@ -1336,6 +1336,7 @@ class TestIndexString(TestcaseBase):
         index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
                                               default_string_index_params)
         cf.assert_equal_index(index, collection_w.indexes[0])
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index, index_name="vector_flat")
         collection_w.load()
         assert collection_w.num_entities == default_nb
 
@@ -1351,6 +1352,7 @@ class TestIndexString(TestcaseBase):
         collection_w = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(ct.default_nb)
         collection_w.insert(data=data)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index, index_name="vector_flat")
         collection_w.load()
         index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
                                               default_string_index_params)

tests/python_client/testcases/test_partition.py

@@ -264,6 +264,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w2 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
         partition_w2.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w1.load()
         error = {ct.err_code: 5, ct.err_msg: f'load the partition after load collection is not supported'}
         partition_w2.load(check_task=CheckTasks.err_res,
@@ -283,6 +284,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w1.insert(cf.gen_default_list_data())
         partition_w2.insert(cf.gen_default_list_data())
         partition_names = ["partition_w1", "partition_w2"]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(partition_names)
         collection_w.release(partition_names)
 
@@ -300,6 +302,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w2 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
         partition_w2.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w1.load()
         partition_w1.release()
         partition_w2.load()
@@ -327,6 +330,7 @@ class TestPartitionParams(TestcaseBase):
 
         # load with non-number replicas
         error = {ct.err_code: 0, ct.err_msg: f"but expected one of: int, long"}
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load(replica_number=get_non_number_replicas, check_task=CheckTasks.err_res, check_items=error)
 
     @pytest.mark.tags(CaseLabel.L2)
@@ -344,6 +348,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w.insert(cf.gen_default_list_data())
         assert partition_w.num_entities == ct.default_nb
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load(replica_number=replicas)
         p_replicas = partition_w.get_replicas()[0]
         assert len(p_replicas.groups) == 1
@@ -366,6 +371,7 @@ class TestPartitionParams(TestcaseBase):
 
         # load with 2 replicas
         error = {ct.err_code: 1, ct.err_msg: f"no enough nodes to create replicas"}
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load(replica_number=3, check_task=CheckTasks.err_res, check_items=error)
 
     @pytest.mark.tags(CaseLabel.ClusterOnly)
@@ -464,6 +470,7 @@ class TestPartitionParams(TestcaseBase):
         # create collection
 
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # create two partitions
         partition_w1 = self.init_partition_wrap(collection_w)
@@ -819,6 +826,7 @@ class TestPartitionOperations(TestcaseBase):
         """
         # create collection
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # create partition
         partition_name = cf.gen_unique_str(prefix)

tests/python_client/testcases/test_query.py

@@ -94,6 +94,7 @@ class TestQueryParams(TestcaseBase):
         """
         c_name = cf.gen_unique_str(prefix)
         collection_w = self.init_collection_wrap(name=c_name)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = collection_w.query(default_term_expr)
         assert len(res) == 0
@@ -115,6 +116,7 @@ class TestQueryParams(TestcaseBase):
         ids = insert_res[1].primary_keys
         pos = 5
         res = df.iloc[:pos, :1].to_dict('records')
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # query with all primary keys
@@ -163,6 +165,7 @@ class TestQueryParams(TestcaseBase):
         df.drop(ct.default_int64_field_name, axis=1, inplace=True)
         mutation_res, _ = collection_w.insert(data=df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         term_expr = f'{ct.default_int64_field_name} in [0, 1, 2]'
         res, _ = collection_w.query(term_expr)
@@ -250,6 +253,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # query by non_primary non_vector scalar field
@@ -283,6 +287,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # output bool field
@@ -327,6 +332,7 @@ class TestQueryParams(TestcaseBase):
         # int8 range [-128, 127] so when nb=1200, there are many repeated int8 values equal to 0
         for i in range(0, ct.default_nb, 256):
             res.extend(df.iloc[i:i + 1, :-1].to_dict('records'))
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         self.collection_wrap.query(term_expr, output_fields=["*"],
                                    check_task=CheckTasks.check_query_results, check_items={exp_res: res})
@@ -393,6 +399,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         values = df[field].tolist()
         pos = 100
@@ -414,6 +421,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         int64_values = df[ct.default_int64_field_name].tolist()
         term_expr = f'{ct.default_int64_field_name} not in {int64_values[pos:]}'
@@ -433,6 +441,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == 100
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # random_values = [random.randint(0, ct.default_nb) for _ in range(4)]
@@ -454,6 +463,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == 50
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         random_values = [i for i in range(10, 50)]
@@ -575,6 +585,7 @@ class TestQueryParams(TestcaseBase):
         assert collection_w.num_entities == ct.default_nb
         fields = [[ct.default_float_vec_field_name], [ct.default_int64_field_name, ct.default_float_vec_field_name]]
         res = df.loc[:1, [ct.default_int64_field_name, ct.default_float_vec_field_name]].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         for output_fields in fields:
             collection_w.query(default_term_expr, output_fields=output_fields,
@@ -603,6 +614,7 @@ class TestQueryParams(TestcaseBase):
         for vec_field in vec_fields:
             output_fields.append(vec_field.name)
         res = df.loc[:1, output_fields].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_term_expr, output_fields=output_fields,
                            check_task=CheckTasks.check_query_results,
@@ -631,6 +643,7 @@ class TestQueryParams(TestcaseBase):
         for vec_field in vec_fields:
             output_fields.append(vec_field.name)
         res = df.loc[:1, output_fields].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_term_expr, output_fields=output_fields,
                            check_task=CheckTasks.check_query_results,
@@ -740,6 +753,7 @@ class TestQueryParams(TestcaseBase):
 
         # query with output_fields=["*", float_vector)
         res = df.iloc[:2, :4].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_term_expr, output_fields=["*", ct.default_float_vec_field_name],
                            check_task=CheckTasks.check_query_results,
@@ -787,6 +801,7 @@ class TestQueryParams(TestcaseBase):
         """
         # init collection with fields: int64, float, float_vec
         collection_w = self.init_collection_general(prefix, insert_data=True, nb=100)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # query with invalid output_fields
@@ -806,6 +821,7 @@ class TestQueryParams(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         partition_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         res = df.iloc[:2, :1].to_dict('records')
         collection_w.query(default_term_expr, partition_names=[partition_w.name],
@@ -849,6 +865,7 @@ class TestQueryParams(TestcaseBase):
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
         partition_w = self.init_partition_wrap(collection_wrap=collection_w)
         assert partition_w.is_empty
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         res, _ = collection_w.query(default_term_expr, partition_names=[partition_w.name])
         assert len(res) == 0
@@ -861,6 +878,7 @@ class TestQueryParams(TestcaseBase):
         expected: raise exception
         """
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix))
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         partition_names = cf.gen_unique_str()
         error = {ct.err_code: 1, ct.err_msg: f'PartitonName: {partition_names} not found'}
@@ -954,6 +972,7 @@ class TestQueryParams(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         partition_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         res = df.iloc[:2, :1].to_dict('records')
         query_params = {"offset": offset, "limit": 10}
@@ -971,6 +990,7 @@ class TestQueryParams(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res = df.iloc[:2, :1].to_dict('records')
         query_params = {"offset": offset, "limit": 10}
@@ -1203,6 +1223,7 @@ class TestQueryOperation(TestcaseBase):
         df[ct.default_int64_field_name] = 0
         mutation_res, _ = collection_w.insert(df)
         assert mutation_res.primary_keys == df[ct.default_int64_field_name].tolist()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         term_expr = f'{ct.default_int64_field_name} in {[0, 0, 0]}'
         res = df.iloc[:, :2].to_dict('records')
@@ -1218,7 +1239,7 @@ class TestQueryOperation(TestcaseBase):
                 3. query
         expected: query result is correct
         """
-        collection_w, vectors, binary_raw_vectors = self.init_collection_general(prefix, insert_data=True)[0:3]
+        collection_w, vectors, binary_raw_vectors = self.init_collection_general(prefix, insert_data=True, is_index=True)[0:3]
 
         default_field_name = ct.default_float_vec_field_name
         collection_w.create_index(default_field_name, default_index_params)
@@ -1285,10 +1306,11 @@ class TestQueryOperation(TestcaseBase):
         method: create index and specify vec field as output field
         expected: return primary field and vec field
         """
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_binary=True)[0:2]
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_binary=True, is_index=True)[0:2]
         fields = [ct.default_int64_field_name, ct.default_binary_vec_field_name]
         collection_w.create_index(ct.default_binary_vec_field_name, binary_index_params)
         assert collection_w.has_index()[0]
+        collection_w.load()
         res, _ = collection_w.query(default_term_expr, output_fields=[ct.default_binary_vec_field_name])
         assert res[0].keys() == set(fields)
 
@@ -1317,6 +1339,7 @@ class TestQueryOperation(TestcaseBase):
         assert collection_w.num_entities == ct.default_nb
 
         # load partition
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
 
         # query twice
@@ -1386,6 +1409,7 @@ class TestQueryOperation(TestcaseBase):
         import time
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
         # load collection
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         tmp_nb = 100
         df = cf.gen_default_dataframe_data(tmp_nb)
@@ -1561,6 +1585,7 @@ class TestqueryString(TestcaseBase):
         assert collection_w.num_entities == ct.default_nb * thread_num
 
         #Check data consistency after parallel insert
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         df_dict_list = []
         for df in df_list:
@@ -1585,7 +1610,7 @@ class TestqueryString(TestcaseBase):
         # 1. create a collection
         schema = cf.gen_string_pk_default_collection_schema()
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix), schema=schema)
-        
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         
         nb = 3000
@@ -1612,7 +1637,7 @@ class TestqueryString(TestcaseBase):
         expected: query successfully
         """
         # 1.  create a collection
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=False)[0:2]
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=False, is_index=True)[0:2]
         
         nb = 3000
         df = cf.gen_default_list_data(nb)
@@ -1620,11 +1645,10 @@ class TestqueryString(TestcaseBase):
 
         collection_w.insert(df)
         assert collection_w.num_entities == nb
-        collection_w.load()
         
         collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
         assert collection_w.has_index()[0]
-
+        collection_w.load()
         
         output_fields = [default_int_field_name, default_float_field_name, default_string_field_name]
         

tests/python_client/testcases/test_search.py

@@ -415,6 +415,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
 
         # 3. search with expression
         log.info("test_search_with_expression: searching with expression: %s" % expression)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         expression = expression.replace("&&", "and").replace("||", "or")
         vectors = [[random.random() for _ in range(dim)] for _ in range(default_nq)]
@@ -561,6 +562,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         # 1. initialize with data
         partition_num = 1
         collection_w = self.init_collection_general(prefix, True, 10, partition_num, is_index=True)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         par = collection_w.partitions
         par_name = par[partition_num].name
         par[partition_num].load()
@@ -600,6 +602,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
                             check_items={"err_code": 1,
                                          "err_msg": err_msg})
         # 3. search collection without data after load
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.search(vectors[:default_nq], default_search_field, default_search_params,
                             default_limit, default_search_exp,
@@ -633,6 +636,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         collection_w = self.init_collection_general(prefix, partition_num=1)[0]
         par = collection_w.partitions
         # 2. search collection without data after load
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.search(vectors[:default_nq], default_search_field, default_search_params,
                             default_limit, default_search_exp,
@@ -667,6 +671,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         deleted_par_name = par[partition_num].name
         collection_w.drop_partition(deleted_par_name)
         log.info("test_search_partition_deleted: deleted a partition")
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # 3. search after delete partitions
         log.info("test_search_partition_deleted: searching deleted partition")
@@ -718,7 +723,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         expected: raise exception and report the error
         """
         # 1. initialize with data
-        collection_w = self.init_collection_general(prefix, True)[0]
+        collection_w = self.init_collection_general(prefix, True, is_index=True)[0]
         # 2. create index
         default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
         collection_w.create_index("float_vector", default_index)
@@ -739,7 +744,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         expected: raise exception and report the error
         """
         # 1. initialize with binary data
-        collection_w = self.init_collection_general(prefix, True, is_binary=True)[0]
+        collection_w = self.init_collection_general(prefix, True, is_binary=True, is_index=True)[0]
         # 2. create index
         default_index = {"index_type": "BIN_IVF_FLAT", "params": {"nlist": 128}, "metric_type": "JACCARD"}
         collection_w.create_index("binary_vector", default_index)
@@ -1123,6 +1128,7 @@ class TestCollectionSearch(TestcaseBase):
         entity_num = nb - deleted_entity_num
         collection_w.drop_partition(par[partition_num].name)
         log.info("test_search_before_after_delete: deleted a partition")
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # 4. search non-deleted part after delete partitions
         log.info("test_search_before_after_delete: searching after deleting partitions")
@@ -1181,6 +1187,7 @@ class TestCollectionSearch(TestcaseBase):
         # 2. insert data
         insert_ids = cf.insert_data(collection_w, nb, auto_id=auto_id, dim=dim)[3]
         # 3. load data
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # 4. flush and load
         collection_w.num_entities
@@ -1261,6 +1268,7 @@ class TestCollectionSearch(TestcaseBase):
         collection_w.insert(dataframe)
 
         # 2. load and search
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         vectors = [[random.random() for _ in range(dim)] for _ in range(default_nq)]
         collection_w.search(vectors[:default_nq], default_search_field,
@@ -1284,7 +1292,7 @@ class TestCollectionSearch(TestcaseBase):
         """
         # 1. connect, create collection and insert data
         self._connect()
-        collection_w = self.init_collection_general(prefix, False, dim=dim)[0]
+        collection_w = self.init_collection_general(prefix, False, dim=dim, is_index=True)[0]
         dataframe = cf.gen_default_dataframe_data(dim=dim, start=-1500)
         collection_w.insert(dataframe)
 
@@ -1391,6 +1399,7 @@ class TestCollectionSearch(TestcaseBase):
         collection_w = self.init_collection_wrap(name=name, shards_num=shards_num)
         dataframe = cf.gen_default_dataframe_data()
         collection_w.insert(dataframe)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
         collection_w.search(vectors[:default_nq], default_search_field,
@@ -1788,10 +1797,10 @@ class TestCollectionSearch(TestcaseBase):
         collection_w.create_partition(partition_name=partition_name, description="search partition empty")
         par = collection_w.partitions
         log.info("test_search_index_partition_empty: partitions: %s" % par)
-        collection_w.load()
         # 3. create index
         default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
         collection_w.create_index("float_vector", default_index)
+        collection_w.load()
         # 4. search the empty partition
         log.info("test_search_index_partition_empty: searching %s "
                  "entities through empty partition" % default_limit)
@@ -2137,7 +2146,7 @@ class TestCollectionSearch(TestcaseBase):
         collection_w, _vectors, _, insert_ids = self.init_collection_general(prefix, True, nb,
                                                                              is_all_data_type=True,
                                                                              auto_id=auto_id,
-                                                                             dim=dim)[0:4]
+                                                                             dim=dim, is_index=True)[0:4]
 
         # 2. create index
         index_param = {"index_type": "IVF_FLAT", "metric_type": "L2", "params": {"nlist": 100}}
@@ -2289,6 +2298,7 @@ class TestCollectionSearch(TestcaseBase):
             filter_ids.extend(_id)
 
         #3. search with expression
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         expression = "int64_1 <= int64_2"
         vectors = [[random.random() for _ in range(dim)] for _ in range(default_nq)]
@@ -2824,6 +2834,7 @@ class TestCollectionSearch(TestcaseBase):
         dataframe = pd.DataFrame({ct.default_int64_field_name: int_values,
                                   field_name1: int_values, field_name2: float_vec_values})
         collection_w.insert(dataframe)
+        collection_w.create_index(field_name2, index_params=ct.default_flat_index)
         collection_w.load()
         vectors = [[random.random() for _ in range(dim)] for _ in range(nq)]
         collection_w.search(vectors[:nq], field_name2, default_search_params,
@@ -2880,7 +2891,7 @@ class TestCollectionSearch(TestcaseBase):
         self._connect()
         collection_w, _, _, insert_ids = self.init_collection_general(prefix, False, nb,
                                                                       auto_id=auto_id,
-                                                                      dim=dim)[0:4]
+                                                                      dim=dim, is_index=True)[0:4]
         collection_w.create_partition(partition_name)
         insert_ids = cf.insert_data(collection_w, nb, auto_id=auto_id, dim=dim)[3]
         collection_w.create_index(default_search_field, default_index_params, index_name=index_name)
@@ -2966,7 +2977,7 @@ class TestSearchBase(TestcaseBase):
         partition_name = "search_partition_empty"
         collection_w.create_partition(partition_name=partition_name, description="search partition empty")
         par = collection_w.partitions
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         if params.get("m"):
             if (dim % params["m"]) != 0:
@@ -3014,7 +3025,7 @@ class TestSearchBase(TestcaseBase):
         # 2. create patition
         partition_name = ct.default_partition_name
         par = collection_w.partitions
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         if params.get("m"):
             if (dim % params["m"]) != 0:
@@ -3132,7 +3143,7 @@ class TestSearchBase(TestcaseBase):
         partition_name = "search_partition_empty"
         collection_w.create_partition(partition_name=partition_name, description="search partition empty")
         par = collection_w.partitions
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         default_index = {"index_type": index, "params": params, "metric_type": "IP"}
         collection_w.create_index("float_vector", default_index)
@@ -3173,7 +3184,7 @@ class TestSearchBase(TestcaseBase):
         vectors = [[random.random() for _ in range(dim)] for _ in range(nq)]
         # 2. create patition
         par_name = collection_w.partitions[0].name
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         default_index = {"index_type": index, "params": params, "metric_type": "IP"}
         collection_w.create_index("float_vector", default_index)
@@ -3196,7 +3207,7 @@ class TestSearchBase(TestcaseBase):
         self._connect()
 
         collection_w, _, _, insert_ids, time_stamp = self.init_collection_general(prefix, True,
-                                                                                  ct.default_nq, is_index=True)[0:5]
+                                                                                  ct.default_nq)[0:5]
         vectors = [[random.random() for _ in range(ct.default_dim)] for _ in range(nq)]
 
         collection_w.load()
@@ -3591,7 +3602,7 @@ class  TestsearchString(TestcaseBase):
         """
         # 1. initialize with data
         collection_w, _, _, insert_ids = \
-            self.init_collection_general(prefix, True, auto_id=auto_id, dim=default_dim)[0:4]
+            self.init_collection_general(prefix, True, auto_id=auto_id, dim=default_dim, is_index=True)[0:4]
         index_param = {"index_type": "IVF_FLAT", "metric_type": "L2", "params": {"nlist": 100}}
         collection_w.create_index("float_vector", index_param, index_name="a")
         index_param_two ={}
@@ -3625,7 +3636,9 @@ class  TestsearchString(TestcaseBase):
         expected: assert index and deleted id not in search result
         """
         # create collection, insert tmp_nb, flush and load
-        collection_w, vectors, _, insert_ids = self.init_collection_general(prefix, insert_data=True, primary_field=ct.default_string_field_name)[0:4]
+        collection_w, vectors, _, insert_ids = self.init_collection_general(prefix, insert_data=True,
+                                                                            primary_field=ct.default_string_field_name,
+                                                                            is_index=True)[0:4]
 
         # create index
         index_params_one = {"index_type": "IVF_SQ8", "metric_type": "L2", "params": {"nlist": 64}}
@@ -3705,7 +3718,7 @@ class  TestsearchString(TestcaseBase):
         """
         # 1. initialize with data
         collection_w, _, _, _= \
-            self.init_collection_general(prefix, False, primary_field=ct.default_int64_field_name)[0:4]
+            self.init_collection_general(prefix, False, primary_field=ct.default_int64_field_name, is_index=True)[0:4]
 
         nb = 3000
         data = cf.gen_default_list_data(nb)

tests/python_client/testcases/test_utility.py

@@ -213,6 +213,7 @@ class TestUtilityParams(TestcaseBase):
         c_name = cf.gen_unique_str(prefix)
         df = cf.gen_default_dataframe_data()
         self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name)
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         error = {ct.err_code: 1, ct.err_msg: "Invalid collection name: {}".format(invalid_c_name)}
         self.utility_wrap.loading_progress(invalid_c_name, check_task=CheckTasks.err_res, check_items=error)
@@ -228,6 +229,7 @@ class TestUtilityParams(TestcaseBase):
         c_name = cf.gen_unique_str(prefix)
         df = cf.gen_default_dataframe_data()
         self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name)
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         error = {ct.err_code: 1, ct.err_msg: "describe collection failed: can't find collection"}
         self.utility_wrap.loading_progress("not_existed_name", check_task=CheckTasks.err_res, check_items=error)
@@ -677,7 +679,7 @@ class TestUtilityBase(TestcaseBase):
         cw = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(nb)
         cw.insert(data=data)
-        error = {ct.err_code: 25, ct.err_msg: "index not exist"}
+        error = {ct.err_code: 25, ct.err_msg: "there is no index on collection"}
         self.utility_wrap.index_building_progress(c_name, check_task=CheckTasks.err_res, check_items=error)
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -810,6 +812,7 @@ class TestUtilityBase(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(_async=True)
         res, _ = self.utility_wrap.loading_progress(collection_w.name)
         loading_int = cf.percent_to_int(res[loading_progress])
@@ -826,6 +829,7 @@ class TestUtilityBase(TestcaseBase):
         expected: 0 entities is loaded
         """
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = self.utility_wrap.loading_progress(collection_w.name)
         exp_res = {loading_progress: '100%'}
@@ -932,6 +936,7 @@ class TestUtilityBase(TestcaseBase):
         """
         self._connect()
         cw = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
+        cw.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         cw.load()
         self.utility_wrap.wait_for_loading_complete(cw.name)
         res, _ = self.utility_wrap.loading_progress(cw.name)
@@ -950,6 +955,7 @@ class TestUtilityBase(TestcaseBase):
         df = cf.gen_default_dataframe_data(nb)
         collection_w.insert(df, timeout=60)
         assert collection_w.num_entities == nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(_async=True)
         self.utility_wrap.wait_for_loading_complete(collection_w.name)
         res, _ = self.utility_wrap.loading_progress(collection_w.name)
@@ -1414,11 +1420,13 @@ class TestUtilityAdvanced(TestcaseBase):
         """
         c_name = cf.gen_unique_str(prefix)
         collection_w = self.init_collection_wrap(name=c_name)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
         assert len(res) == 0
 
     @pytest.mark.tags(CaseLabel.L1)
+    @pytest.mark.skip("index must created before load, but create_index will trigger flush")
     def test_get_sealed_query_segment_info(self):
         """
         target: test getting sealed query segment info of collection without index
@@ -1432,6 +1440,7 @@ class TestUtilityAdvanced(TestcaseBase):
         df = cf.gen_default_dataframe_data(nb)
         collection_w.insert(df)
         collection_w.num_entities
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
         assert len(res) == 0
@@ -1531,6 +1540,7 @@ class TestUtilityAdvanced(TestcaseBase):
         collection_w.num_entities
         # get growing segments
         collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # prepare load balance params
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
@@ -1568,6 +1578,7 @@ class TestUtilityAdvanced(TestcaseBase):
         collection_w.num_entities
         # get growing segments
         collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # prepare load balance params
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
@@ -1681,6 +1692,7 @@ class TestUtilityAdvanced(TestcaseBase):
         collection_w.insert(df)
         # get sealed segments
         collection_w.num_entities
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(replica_number=2)
         # get growing segments
         collection_w.insert(df)