milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Must create index before load (#19516) 

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

Signed-off-by: cai.zhang <cai.zhang@zilliz.com>
pull/19835/head
cai.zhang 2022-10-17 18:01:25 +08:00 committed by GitHub
parent 760e9c5df2
commit 9d43947f1c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 700 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
internal/proto/query_coord.proto
View File

@ -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 {

504
internal/proto/querypb/query_coord.pb.go
View File

@ -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.

2
internal/proxy/impl.go
View File

@ -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(

11
internal/proxy/index_coord_mock_test.go
View File

@ -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{}
}

2
internal/proxy/rootcoord_mock_test.go
View File

@ -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

69
internal/proxy/task.go
View File

@ -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

3
internal/proxy/task_index.go
View File

@ -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{

196
internal/proxy/task_test.go
View File

@ -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)
})
}

10
tests/python_client/base/client_base.py
View File

@ -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

3
tests/python_client/common/common_type.py
View File

@ -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 = [
[],

2
tests/python_client/requirements.txt
View File

@ -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

24
tests/python_client/testcases/test_collection.py
View File

@ -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)

3
tests/python_client/testcases/test_compaction.py
View File

@ -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)

35
tests/python_client/testcases/test_delete.py
View File

@ -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

4
tests/python_client/testcases/test_e2e.py
View File

@ -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}}

2
tests/python_client/testcases/test_index.py
View File

@ -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)

8
tests/python_client/testcases/test_partition.py
View File

@ -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)

36
tests/python_client/testcases/test_query.py
View File

@ -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]

41
tests/python_client/testcases/test_search.py
View File

@ -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)

14
tests/python_client/testcases/test_utility.py
View File

@ -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)