admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Release collection and partitions

Browse Source 
Signed-off-by: bigsheeper <yihao.dai@zilliz.com>
This commit is contained in:
bigsheeper 2021-02-24 17:24:51 +08:00 committed by yefu.chen
parent 0679954922
commit 08a020798e
13 changed files with 271 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
internal/distributed/querynode/client/client.go
View File

@ -93,6 +93,14 @@ func (c *Client) LoadSegments(in *querypb.LoadSegmentRequest) (*commonpb.Status,
return c.grpcClient.LoadSegments(context.TODO(), in)
}
func (c *Client) ReleaseCollection(in *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
return c.grpcClient.ReleaseCollection(context.TODO(), in)
}
func (c *Client) ReleasePartitions(in *querypb.ReleasePartitionRequest) (*commonpb.Status, error) {
return c.grpcClient.ReleasePartitions(context.TODO(), in)
}
func (c *Client) ReleaseSegments(in *querypb.ReleaseSegmentRequest) (*commonpb.Status, error) {
return c.grpcClient.ReleaseSegments(context.TODO(), in)
}

10
internal/distributed/querynode/service.go
View File

@ -317,6 +317,16 @@ func (s *Server) LoadSegments(ctx context.Context, in *querypb.LoadSegmentReques
return s.impl.LoadSegments(in)
}
func (s *Server) ReleaseCollection(ctx context.Context, in *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
// ignore ctx
return s.impl.ReleaseCollection(in)
}
func (s *Server) ReleasePartitions(ctx context.Context, in *querypb.ReleasePartitionRequest) (*commonpb.Status, error) {
// ignore ctx
return s.impl.ReleasePartitions(in)
}
func (s *Server) ReleaseSegments(ctx context.Context, in *querypb.ReleaseSegmentRequest) (*commonpb.Status, error) {
// ignore ctx
return s.impl.ReleaseSegments(in)

6
internal/indexnode/index.go
View File

@ -165,9 +165,9 @@ func (index *CIndex) Load(blobs []*Blob) error {
binarySet.Datas = append(binarySet.Datas, &indexcgopb.Binary{Key: blob.Key, Value: blob.Value})
}
datas, err := proto.Marshal(binarySet)
if err != nil {
return err
datas, err2 := proto.Marshal(binarySet)
if err2 != nil {
return err2
}
/*

2
internal/proto/query_service.proto
View File

@ -193,6 +193,8 @@ service QueryNode {
rpc RemoveQueryChannel(RemoveQueryChannelsRequest) returns (common.Status) {}
rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) {}
rpc LoadSegments(LoadSegmentRequest) returns (common.Status) {}
rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) {}
rpc ReleasePartitions(ReleasePartitionRequest) returns (common.Status) {}
rpc ReleaseSegments(ReleaseSegmentRequest) returns (common.Status) {}
rpc GetSegmentInfo(SegmentInfoRequest) returns (SegmentInfoResponse) {}
}

247
internal/proto/querypb/query_service.pb.go
View File

@ -1420,93 +1420,94 @@ func init() {
func init() { proto.RegisterFile("query_service.proto", fileDescriptor_5fcb6756dc1afb8d) }
var fileDescriptor_5fcb6756dc1afb8d = []byte{
// 1375 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xdd, 0x6e, 0x1b, 0xc5,
0x17, 0xcf, 0xc6, 0x8e, 0x13, 0x9f, 0xb8, 0xb6, 0x3b, 0xf9, 0xf2, 0x7f, 0xff, 0xa5, 0x94, 0x81,
0xb6, 0x69, 0x0b, 0x0e, 0x4a, 0x05, 0xe2, 0x06, 0x50, 0x1b, 0x57, 0x95, 0x11, 0x0d, 0x61, 0xdd,
0xaa, 0x22, 0x50, 0x99, 0xf5, 0xee, 0x24, 0x9e, 0xd6, 0xbb, 0xeb, 0xee, 0x8c, 0xfb, 0x91, 0x1b,
0x40, 0xe2, 0x12, 0xc1, 0x33, 0x20, 0x24, 0x90, 0x78, 0x0a, 0x9e, 0x82, 0x1b, 0x6e, 0x40, 0x5c,
0xf0, 0x1a, 0x68, 0x67, 0xc7, 0x9b, 0xdd, 0xf5, 0x38, 0xeb, 0xc6, 0x6d, 0xc3, 0xdd, 0xce, 0xd9,
0x73, 0xce, 0xef, 0x7c, 0xcd, 0x99, 0x73, 0x60, 0xe9, 0xe1, 0x80, 0xf8, 0x4f, 0xdb, 0x8c, 0xf8,
0x8f, 0xa8, 0x45, 0xea, 0x7d, 0xdf, 0xe3, 0x1e, 0x42, 0x0e, 0xed, 0x3d, 0x1a, 0xb0, 0xf0, 0x54,
0x17, 0x1c, 0x7a, 0xc9, 0xf2, 0x1c, 0xc7, 0x73, 0x43, 0x9a, 0x5e, 0x8a, 0x73, 0xe8, 0x65, 0xea,
0x72, 0xe2, 0xbb, 0x66, 0x4f, 0x9e, 0x91, 0x6d, 0x72, 0x33, 0xa9, 0x53, 0x2f, 0x31, 0xab, 0x4b,
0x1c, 0x33, 0x3c, 0xe1, 0xaf, 0x60, 0xc9, 0x20, 0xfb, 0x94, 0x71, 0xe2, 0x6f, 0x7b, 0x36, 0x31,
0xc8, 0xc3, 0x01, 0x61, 0x1c, 0xbd, 0x0d, 0xf9, 0x8e, 0xc9, 0x48, 0x4d, 0x3b, 0xa7, 0xad, 0x2f,
0x6e, 0x9e, 0xa9, 0x27, 0xec, 0x90, 0x06, 0xdc, 0x62, 0xfb, 0xd7, 0x4d, 0x46, 0x0c, 0xc1, 0x89,
0xde, 0x85, 0x79, 0xd3, 0xb6, 0x7d, 0xc2, 0x58, 0x6d, 0xf6, 0x08, 0xa1, 0x6b, 0x21, 0x8f, 0x31,
0x64, 0xc6, 0x3f, 0x68, 0xb0, 0x9c, 0xb4, 0x80, 0xf5, 0x3d, 0x97, 0x11, 0x74, 0x15, 0x0a, 0x8c,
0x9b, 0x7c, 0xc0, 0xa4, 0x11, 0xff, 0x57, 0xea, 0x6b, 0x09, 0x16, 0x43, 0xb2, 0xa2, 0xeb, 0xb0,
0x48, 0x5d, 0xca, 0xdb, 0x7d, 0xd3, 0x37, 0x9d, 0xa1, 0x25, 0xaf, 0x25, 0x25, 0xa3, 0x18, 0x35,
0x5d, 0xca, 0x77, 0x04, 0xa3, 0x01, 0x34, 0xfa, 0xc6, 0xf7, 0x60, 0xa5, 0xd5, 0xf5, 0x1e, 0x6f,
0x79, 0xbd, 0x1e, 0xb1, 0x38, 0xf5, 0xdc, 0xe3, 0x07, 0x05, 0x41, 0xde, 0xee, 0x34, 0x1b, 0xc2,
0x8e, 0x9c, 0x21, 0xbe, 0x31, 0x83, 0xd5, 0xb4, 0xfa, 0x69, 0x3c, 0x7e, 0x03, 0x4e, 0x59, 0x91,
0xaa, 0x66, 0x23, 0xf0, 0x39, 0xb7, 0x9e, 0x33, 0x92, 0x44, 0xfc, 0x9b, 0x06, 0x2b, 0x1f, 0x7b,
0xa6, 0xfd, 0x82, 0x9c, 0x42, 0x18, 0x4a, 0x71, 0xc0, 0x5a, 0x4e, 0xfc, 0x4b, 0xd0, 0xd0, 0xfb,
0x50, 0x08, 0x4b, 0xaf, 0x96, 0x17, 0x58, 0xe7, 0x93, 0x58, 0xb2, 0x2c, 0x0f, 0x2d, 0x6c, 0x09,
0x82, 0x21, 0x85, 0xf0, 0xb7, 0x1a, 0xd4, 0x0c, 0xd2, 0x23, 0x26, 0x23, 0x27, 0xe8, 0x05, 0xfe,
0x5a, 0x83, 0xe5, 0x20, 0x7f, 0x3b, 0xa6, 0xcf, 0xe9, 0xc9, 0x98, 0xd0, 0x0f, 0x0b, 0x34, 0x66,
0xc1, 0x34, 0x05, 0x84, 0xa1, 0xd4, 0x1f, 0x6a, 0x3a, 0xac, 0x9f, 0x04, 0x0d, 0x3b, 0x50, 0x89,
0xd0, 0x02, 0x71, 0xc2, 0xd0, 0x39, 0x58, 0x8c, 0xb1, 0x08, 0xc0, 0x9c, 0x11, 0x27, 0xa1, 0xf7,
0x60, 0x2e, 0x80, 0x20, 0xc2, 0xbf, 0xf2, 0x26, 0xae, 0x8f, 0x36, 0xb3, 0x7a, 0x52, 0xab, 0x11,
0x0a, 0xe0, 0x9f, 0x35, 0x58, 0x4d, 0xe1, 0xbd, 0xfc, 0x72, 0x4d, 0xc7, 0x25, 0xaf, 0x88, 0xcb,
0xaf, 0x1a, 0xac, 0x8d, 0x18, 0x3a, 0x4d, 0x32, 0x76, 0x61, 0x35, 0x02, 0x68, 0xdb, 0x84, 0x59,
0x3e, 0xed, 0x07, 0xdf, 0x61, 0x5a, 0x16, 0x37, 0x5f, 0xcf, 0x0e, 0x22, 0x33, 0x56, 0x22, 0x15,
0x8d, 0x98, 0x06, 0xfc, 0xb7, 0x06, 0xcb, 0x41, 0x0f, 0x38, 0xb9, 0xca, 0x9d, 0x24, 0xa6, 0xb1,
0x36, 0x31, 0x77, 0x9c, 0x36, 0xf1, 0x8b, 0x06, 0x6b, 0xb2, 0x4d, 0xfc, 0xb7, 0x1d, 0xc5, 0x3f,
0x6a, 0xa0, 0x6f, 0xf9, 0xc4, 0xe4, 0xe4, 0xd3, 0x20, 0x8d, 0x5b, 0x5d, 0xd3, 0x75, 0x49, 0x6f,
0xba, 0xfa, 0xb9, 0x08, 0x15, 0x3f, 0x74, 0xb6, 0x6d, 0x85, 0xfa, 0x84, 0xe9, 0x45, 0xa3, 0x2c,
0xc9, 0x12, 0x05, 0x9d, 0x87, 0xb2, 0x4f, 0xd8, 0xa0, 0x77, 0xc8, 0x97, 0x13, 0x7c, 0xa7, 0x42,
0xaa, 0x64, 0xc3, 0x3f, 0x69, 0xb0, 0x76, 0xcd, 0xb6, 0xe3, 0x06, 0x4e, 0x71, 0x15, 0xaf, 0xc0,
0xe9, 0x94, 0x75, 0x32, 0xb4, 0x45, 0xa3, 0x9a, 0xb4, 0xaf, 0xd9, 0x40, 0x97, 0xa0, 0x9a, 0xb4,
0x50, 0x86, 0xba, 0x68, 0x54, 0x12, 0x36, 0x36, 0x1b, 0xf8, 0x0f, 0x0d, 0x74, 0x83, 0x38, 0xde,
0x23, 0xa2, 0x34, 0xf4, 0x58, 0x91, 0x1c, 0x7a, 0x37, 0x3b, 0x9d, 0x77, 0xb9, 0x67, 0xf0, 0x2e,
0xaf, 0xf6, 0xee, 0x3e, 0xac, 0xde, 0x35, 0xb9, 0xd5, 0x6d, 0x38, 0xd3, 0x67, 0xe0, 0x2c, 0x40,
0x84, 0x17, 0xf6, 0x94, 0xa2, 0x11, 0xa3, 0xe0, 0x7f, 0x66, 0x01, 0x05, 0x3d, 0xa2, 0x45, 0xf6,
0x1d, 0xe2, 0xf2, 0x97, 0x7f, 0x71, 0x52, 0xcf, 0x4a, 0x7e, 0xf4, 0x59, 0x39, 0x0b, 0xc0, 0x42,
0xeb, 0x02, 0x17, 0xe6, 0xc4, 0xc5, 0x8a, 0x51, 0x90, 0x0e, 0x0b, 0x7b, 0x94, 0xf4, 0xec, 0xe0,
0x6f, 0x41, 0xfc, 0x8d, 0xce, 0xe8, 0x23, 0x28, 0x4b, 0xce, 0xb6, 0x78, 0x69, 0x58, 0x6d, 0x5e,
0xd5, 0x56, 0x83, 0xa9, 0xb9, 0x2e, 0x43, 0x20, 0x7a, 0x6a, 0xd3, 0xdd, 0xf3, 0x8c, 0x53, 0x2c,
0x46, 0x89, 0xf7, 0xa9, 0x85, 0xe3, 0xf4, 0xa9, 0xbf, 0x34, 0x58, 0x91, 0x7d, 0xea, 0xc4, 0x82,
0x3d, 0x49, 0x3b, 0x9e, 0x22, 0xdc, 0xf8, 0x7b, 0x0d, 0xd6, 0xb6, 0x3c, 0xa7, 0xef, 0xb9, 0x51,
0xd8, 0xa6, 0x6b, 0x6f, 0x1f, 0x84, 0x42, 0x64, 0x38, 0xd9, 0x5f, 0x18, 0x33, 0xd9, 0xa7, 0x41,
0xa5, 0x14, 0xfe, 0x53, 0x83, 0x45, 0x19, 0xed, 0x20, 0xa5, 0xe8, 0x0c, 0x14, 0x23, 0x57, 0xe4,
0x08, 0x73, 0x48, 0x18, 0x09, 0xe1, 0x6c, 0x76, 0xbd, 0xe6, 0x46, 0xeb, 0xf5, 0x7f, 0xb0, 0xe0,
0x10, 0xa7, 0xcd, 0xe8, 0x01, 0x91, 0xe5, 0x3c, 0xef, 0x10, 0xa7, 0x45, 0x0f, 0x48, 0xf0, 0xcb,
0x1d, 0x38, 0x6d, 0xdf, 0x7b, 0xcc, 0xc4, 0x63, 0x97, 0x33, 0xe6, 0xdd, 0x81, 0x63, 0x78, 0x8f,
0x19, 0x7a, 0x05, 0x80, 0xba, 0x36, 0x79, 0xd2, 0x76, 0x4d, 0x87, 0xd4, 0x0a, 0xa2, 0x33, 0x14,
0x05, 0x65, 0xdb, 0x74, 0x08, 0xaa, 0xc1, 0xbc, 0x38, 0x34, 0x1b, 0xb5, 0xf9, 0x50, 0x50, 0x1e,
0xf1, 0x1e, 0xa0, 0x98, 0x87, 0x53, 0x75, 0x8a, 0x58, 0xde, 0x67, 0xd3, 0x79, 0xc7, 0xdf, 0x68,
0xb0, 0x94, 0x00, 0x9a, 0x26, 0xaf, 0xef, 0xc0, 0x1c, 0x75, 0xf7, 0xbc, 0xe1, 0x94, 0xf3, 0xaa,
0x6a, 0xca, 0x89, 0x83, 0x85, 0xdc, 0x97, 0x0f, 0xa0, 0x9c, 0x9c, 0x7d, 0x50, 0x09, 0x16, 0xb6,
0x3d, 0x7e, 0xe3, 0x09, 0x65, 0xbc, 0x3a, 0x83, 0xca, 0x00, 0xdb, 0x1e, 0xdf, 0xf1, 0x09, 0x23,
0x2e, 0xaf, 0x6a, 0x08, 0xa0, 0xf0, 0x89, 0xdb, 0xa0, 0xec, 0x41, 0x75, 0x16, 0x2d, 0xc9, 0x91,
0xd6, 0xec, 0x35, 0xdd, 0x5b, 0xc4, 0xf1, 0xfc, 0xa7, 0xd5, 0x5c, 0x20, 0x1e, 0x9d, 0xf2, 0xa8,
0x0a, 0xa5, 0x88, 0xe5, 0xe6, 0xce, 0x9d, 0xea, 0x1c, 0x2a, 0xc2, 0x5c, 0xf8, 0x59, 0xd8, 0xfc,
0x0e, 0xa0, 0x24, 0x5e, 0x9b, 0x56, 0xb8, 0x5d, 0x23, 0x0b, 0x4a, 0xf1, 0x3d, 0x16, 0x5d, 0x54,
0x39, 0xa1, 0xd8, 0xb5, 0xf5, 0xf5, 0x6c, 0xc6, 0x30, 0xb6, 0x78, 0x06, 0xdd, 0x87, 0x4a, 0x72,
0x79, 0x64, 0xe8, 0x92, 0x32, 0x58, 0xaa, 0x05, 0x56, 0xbf, 0x3c, 0x09, 0x6b, 0x84, 0xb5, 0x0f,
0xe5, 0xc4, 0x9a, 0xc1, 0xd0, 0xfa, 0x38, 0xf9, 0xf4, 0xa4, 0xa5, 0x5f, 0x9a, 0x80, 0x33, 0x02,
0xfa, 0x0c, 0xca, 0x89, 0xb9, 0x74, 0x0c, 0x90, 0x6a, 0x76, 0xd5, 0x8f, 0x2a, 0x2f, 0x3c, 0x83,
0xda, 0x70, 0x3a, 0x3d, 0x0c, 0x32, 0x74, 0x45, 0x1d, 0x70, 0xe5, 0xcc, 0x98, 0x05, 0xb0, 0x1b,
0xda, 0x7e, 0x18, 0x40, 0x75, 0x3e, 0x94, 0xbb, 0x77, 0x96, 0xee, 0x2f, 0x23, 0xe3, 0x63, 0xea,
0xdf, 0x3c, 0xc2, 0xf8, 0x67, 0x46, 0xe8, 0x00, 0x1a, 0x9d, 0x40, 0x91, 0xae, 0x14, 0xba, 0xe1,
0xf4, 0xf9, 0x53, 0xbd, 0xae, 0x82, 0x1f, 0x3f, 0xc5, 0xe2, 0x19, 0x74, 0x17, 0xd0, 0x4d, 0xc2,
0x6f, 0x53, 0x87, 0xdc, 0xa6, 0xd6, 0x83, 0x49, 0x30, 0x52, 0xaf, 0xb1, 0x3c, 0xb4, 0xb8, 0x4f,
0xdd, 0xfd, 0x44, 0xd9, 0x2c, 0xdf, 0x24, 0xa2, 0xc3, 0x53, 0xc6, 0xa9, 0xc5, 0x9e, 0xa3, 0x6a,
0x4f, 0xd8, 0x9c, 0x5e, 0x79, 0x2f, 0x4f, 0xb2, 0x7c, 0xc9, 0xc0, 0x5f, 0x99, 0x88, 0x37, 0x02,
0xdc, 0x15, 0x80, 0xa9, 0x67, 0xeb, 0x48, 0x4f, 0x26, 0x7c, 0xfa, 0xf0, 0x0c, 0xb2, 0xa0, 0x1c,
0xc4, 0x29, 0xf6, 0xec, 0x5d, 0xc8, 0xea, 0xaf, 0xd2, 0x89, 0x8b, 0x99, 0x7c, 0x43, 0x07, 0x36,
0x7f, 0x2f, 0x40, 0x51, 0x14, 0x80, 0xe8, 0x7d, 0x2f, 0x2c, 0xe7, 0xb7, 0xa1, 0x22, 0x73, 0xfe,
0x3c, 0xd3, 0xdd, 0x7e, 0xe6, 0xe8, 0x2b, 0xd3, 0x3b, 0x66, 0xd4, 0xc1, 0x33, 0xe8, 0x1e, 0x54,
0x52, 0x5b, 0x94, 0xba, 0x09, 0x8d, 0x59, 0xb5, 0xb2, 0xae, 0xb1, 0x05, 0x68, 0x74, 0xfd, 0x41,
0x75, 0x75, 0xa7, 0x18, 0xb7, 0x26, 0x65, 0x81, 0x7c, 0x01, 0x95, 0xd4, 0x1a, 0xa2, 0xbe, 0x10,
0xea, 0x5d, 0x25, 0x4b, 0xfb, 0x1d, 0x28, 0xc5, 0xf6, 0x0e, 0xa6, 0x2e, 0xd1, 0xd1, 0xcd, 0x24,
0x4b, 0xed, 0xe7, 0x50, 0x49, 0x0e, 0xd9, 0x63, 0xde, 0x4b, 0xe5, 0x24, 0x9e, 0x1d, 0xf6, 0x17,
0x7f, 0xb1, 0xae, 0x5f, 0xdb, 0xfd, 0x70, 0x9f, 0xf2, 0xee, 0xa0, 0x13, 0xc0, 0x6f, 0x1c, 0xd0,
0x5e, 0x8f, 0x1e, 0x70, 0x62, 0x75, 0x37, 0x42, 0x0d, 0x6f, 0xd9, 0x94, 0x71, 0x9f, 0x76, 0x06,
0x9c, 0xd8, 0x1b, 0xc3, 0x26, 0xb0, 0x21, 0xd4, 0x6e, 0x08, 0xb5, 0xfd, 0x4e, 0xa7, 0x20, 0x8e,
0x57, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xb8, 0x72, 0x8c, 0x04, 0x63, 0x18, 0x00, 0x00,
// 1379 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x5d, 0x6f, 0x1b, 0x45,
0x17, 0xce, 0xc6, 0x8e, 0x13, 0x9f, 0xb8, 0xb6, 0x3b, 0xf9, 0xf2, 0xbb, 0x6f, 0x29, 0x65, 0xa0,
0x6d, 0xda, 0x82, 0x83, 0x52, 0x81, 0xb8, 0x01, 0xd4, 0xc6, 0x55, 0x65, 0x44, 0x43, 0x58, 0xb7,
0xaa, 0x08, 0x54, 0x66, 0xbd, 0x3b, 0xb1, 0xa7, 0xf5, 0xee, 0xba, 0x3b, 0xe3, 0x7e, 0xe4, 0x06,
0x90, 0xb8, 0x44, 0x70, 0xcd, 0x25, 0x42, 0x02, 0x89, 0x5f, 0xc1, 0xff, 0xe0, 0x06, 0xc4, 0x05,
0x7f, 0x03, 0xed, 0xec, 0x78, 0xb3, 0xbb, 0x1e, 0xc7, 0x4e, 0xdc, 0x34, 0xdc, 0x79, 0x8e, 0xcf,
0x9c, 0xe7, 0x7c, 0xed, 0x33, 0xe7, 0xc0, 0xd2, 0xe3, 0x3e, 0xf1, 0x9f, 0x37, 0x19, 0xf1, 0x9f,
0x50, 0x8b, 0x54, 0x7b, 0xbe, 0xc7, 0x3d, 0x84, 0x1c, 0xda, 0x7d, 0xd2, 0x67, 0xe1, 0xa9, 0x2a,
0x34, 0xf4, 0x82, 0xe5, 0x39, 0x8e, 0xe7, 0x86, 0x32, 0xbd, 0x10, 0xd7, 0xd0, 0x8b, 0xd4, 0xe5,
0xc4, 0x77, 0xcd, 0xae, 0x3c, 0x23, 0xdb, 0xe4, 0x66, 0xd2, 0xa6, 0x5e, 0x60, 0x56, 0x87, 0x38,
0x66, 0x78, 0xc2, 0x5f, 0xc1, 0x92, 0x41, 0xda, 0x94, 0x71, 0xe2, 0x6f, 0x7b, 0x36, 0x31, 0xc8,
0xe3, 0x3e, 0x61, 0x1c, 0xbd, 0x0d, 0xd9, 0x96, 0xc9, 0x48, 0x45, 0xbb, 0xa0, 0xad, 0x2f, 0x6e,
0x9e, 0xab, 0x26, 0xfc, 0x90, 0x0e, 0xdc, 0x61, 0xed, 0x9b, 0x26, 0x23, 0x86, 0xd0, 0x44, 0xef,
0xc2, 0xbc, 0x69, 0xdb, 0x3e, 0x61, 0xac, 0x32, 0x7b, 0xc8, 0xa5, 0x1b, 0xa1, 0x8e, 0x31, 0x50,
0xc6, 0x3f, 0x68, 0xb0, 0x9c, 0xf4, 0x80, 0xf5, 0x3c, 0x97, 0x11, 0x74, 0x1d, 0x72, 0x8c, 0x9b,
0xbc, 0xcf, 0xa4, 0x13, 0xff, 0x57, 0xda, 0x6b, 0x08, 0x15, 0x43, 0xaa, 0xa2, 0x9b, 0xb0, 0x48,
0x5d, 0xca, 0x9b, 0x3d, 0xd3, 0x37, 0x9d, 0x81, 0x27, 0xaf, 0x25, 0x6f, 0x46, 0x39, 0xaa, 0xbb,
0x94, 0xef, 0x08, 0x45, 0x03, 0x68, 0xf4, 0x1b, 0x3f, 0x80, 0x95, 0x46, 0xc7, 0x7b, 0xba, 0xe5,
0x75, 0xbb, 0xc4, 0xe2, 0xd4, 0x73, 0x8f, 0x9f, 0x14, 0x04, 0x59, 0xbb, 0x55, 0xaf, 0x09, 0x3f,
0x32, 0x86, 0xf8, 0x8d, 0x19, 0xac, 0xa6, 0xcd, 0x4f, 0x13, 0xf1, 0x1b, 0x70, 0xc6, 0x8a, 0x4c,
0xd5, 0x6b, 0x41, 0xcc, 0x99, 0xf5, 0x8c, 0x91, 0x14, 0xe2, 0xdf, 0x35, 0x58, 0xf9, 0xd8, 0x33,
0xed, 0x13, 0x0a, 0x0a, 0x61, 0x28, 0xc4, 0x01, 0x2b, 0x19, 0xf1, 0x5f, 0x42, 0x86, 0xde, 0x87,
0x5c, 0xd8, 0x7a, 0x95, 0xac, 0xc0, 0xba, 0x98, 0xc4, 0x92, 0x6d, 0x79, 0xe0, 0x61, 0x43, 0x08,
0x0c, 0x79, 0x09, 0x7f, 0xab, 0x41, 0xc5, 0x20, 0x5d, 0x62, 0x32, 0x72, 0x8a, 0x51, 0xe0, 0xaf,
0x35, 0x58, 0x0e, 0xea, 0xb7, 0x63, 0xfa, 0x9c, 0x9e, 0x8e, 0x0b, 0xbd, 0xb0, 0x41, 0x63, 0x1e,
0x4c, 0xd3, 0x40, 0x18, 0x0a, 0xbd, 0x81, 0xa5, 0x83, 0xfe, 0x49, 0xc8, 0xb0, 0x03, 0xa5, 0x08,
0x2d, 0xb8, 0x4e, 0x18, 0xba, 0x00, 0x8b, 0x31, 0x15, 0x01, 0x98, 0x31, 0xe2, 0x22, 0xf4, 0x1e,
0xcc, 0x05, 0x10, 0x44, 0xc4, 0x57, 0xdc, 0xc4, 0xd5, 0x61, 0x32, 0xab, 0x26, 0xad, 0x1a, 0xe1,
0x05, 0xfc, 0x8b, 0x06, 0xab, 0x29, 0xbc, 0x97, 0xdf, 0xae, 0xe9, 0xbc, 0x64, 0x15, 0x79, 0xf9,
0x4d, 0x83, 0xb5, 0x21, 0x47, 0xa7, 0x29, 0xc6, 0x2e, 0xac, 0x46, 0x00, 0x4d, 0x9b, 0x30, 0xcb,
0xa7, 0xbd, 0xe0, 0x77, 0x58, 0x96, 0xc5, 0xcd, 0xd7, 0xc7, 0x27, 0x91, 0x19, 0x2b, 0x91, 0x89,
0x5a, 0xcc, 0x02, 0xfe, 0x5b, 0x83, 0xe5, 0x80, 0x03, 0x4e, 0xaf, 0x73, 0x27, 0xc9, 0x69, 0x8c,
0x26, 0xe6, 0x8e, 0x43, 0x13, 0xbf, 0x6a, 0xb0, 0x26, 0x69, 0xe2, 0xbf, 0x1d, 0x28, 0xfe, 0x49,
0x03, 0x7d, 0xcb, 0x27, 0x26, 0x27, 0x9f, 0x06, 0x65, 0xdc, 0xea, 0x98, 0xae, 0x4b, 0xba, 0xd3,
0xf5, 0xcf, 0x65, 0x28, 0xf9, 0x61, 0xb0, 0x4d, 0x2b, 0xb4, 0x27, 0x5c, 0xcf, 0x1b, 0x45, 0x29,
0x96, 0x28, 0xe8, 0x22, 0x14, 0x7d, 0xc2, 0xfa, 0xdd, 0x03, 0xbd, 0x8c, 0xd0, 0x3b, 0x13, 0x4a,
0xa5, 0x1a, 0xfe, 0x59, 0x83, 0xb5, 0x1b, 0xb6, 0x1d, 0x77, 0x70, 0x8a, 0x4f, 0xf1, 0x1a, 0x9c,
0x4d, 0x79, 0x27, 0x53, 0x9b, 0x37, 0xca, 0x49, 0xff, 0xea, 0x35, 0x74, 0x05, 0xca, 0x49, 0x0f,
0x65, 0xaa, 0xf3, 0x46, 0x29, 0xe1, 0x63, 0xbd, 0x86, 0xff, 0xd0, 0x40, 0x37, 0x88, 0xe3, 0x3d,
0x21, 0x4a, 0x47, 0x8f, 0x95, 0xc9, 0x41, 0x74, 0xb3, 0xd3, 0x45, 0x97, 0x39, 0x42, 0x74, 0x59,
0x75, 0x74, 0x0f, 0x61, 0xf5, 0xbe, 0xc9, 0xad, 0x4e, 0xcd, 0x99, 0xbe, 0x02, 0xe7, 0x01, 0x22,
0xbc, 0x90, 0x53, 0xf2, 0x46, 0x4c, 0x82, 0xff, 0x99, 0x05, 0x14, 0x70, 0x44, 0x83, 0xb4, 0x1d,
0xe2, 0xf2, 0x97, 0xff, 0xe1, 0xa4, 0x9e, 0x95, 0xec, 0xf0, 0xb3, 0x72, 0x1e, 0x80, 0x85, 0xde,
0x05, 0x21, 0xcc, 0x89, 0x0f, 0x2b, 0x26, 0x41, 0x3a, 0x2c, 0xec, 0x51, 0xd2, 0xb5, 0x83, 0x7f,
0x73, 0xe2, 0xdf, 0xe8, 0x8c, 0x3e, 0x82, 0xa2, 0xd4, 0x6c, 0x8a, 0x97, 0x86, 0x55, 0xe6, 0x55,
0xb4, 0x1a, 0x4c, 0xcd, 0x55, 0x99, 0x02, 0xc1, 0xa9, 0x75, 0x77, 0xcf, 0x33, 0xce, 0xb0, 0x98,
0x24, 0xce, 0x53, 0x0b, 0xc7, 0xe1, 0xa9, 0xbf, 0x34, 0x58, 0x91, 0x3c, 0x75, 0x6a, 0xc9, 0x9e,
0x84, 0x8e, 0xa7, 0x48, 0x37, 0xfe, 0x5e, 0x83, 0xb5, 0x2d, 0xcf, 0xe9, 0x79, 0x6e, 0x94, 0xb6,
0xe9, 0xe8, 0xed, 0x83, 0xf0, 0x12, 0x19, 0x4c, 0xf6, 0x97, 0x46, 0x4c, 0xf6, 0x69, 0x50, 0x79,
0x0b, 0xff, 0xa9, 0xc1, 0xa2, 0xcc, 0x76, 0x50, 0x52, 0x74, 0x0e, 0xf2, 0x51, 0x28, 0x72, 0x84,
0x39, 0x10, 0x0c, 0xa5, 0x70, 0x76, 0x7c, 0xbf, 0x66, 0x86, 0xfb, 0xf5, 0x7f, 0xb0, 0xe0, 0x10,
0xa7, 0xc9, 0xe8, 0x3e, 0x91, 0xed, 0x3c, 0xef, 0x10, 0xa7, 0x41, 0xf7, 0x49, 0xf0, 0x97, 0xdb,
0x77, 0x9a, 0xbe, 0xf7, 0x94, 0x89, 0xc7, 0x2e, 0x63, 0xcc, 0xbb, 0x7d, 0xc7, 0xf0, 0x9e, 0x32,
0xf4, 0x0a, 0x00, 0x75, 0x6d, 0xf2, 0xac, 0xe9, 0x9a, 0x0e, 0xa9, 0xe4, 0x04, 0x33, 0xe4, 0x85,
0x64, 0xdb, 0x74, 0x08, 0xaa, 0xc0, 0xbc, 0x38, 0xd4, 0x6b, 0x95, 0xf9, 0xf0, 0xa2, 0x3c, 0xe2,
0x3d, 0x40, 0xb1, 0x08, 0xa7, 0x62, 0x8a, 0x58, 0xdd, 0x67, 0xd3, 0x75, 0xc7, 0xdf, 0x68, 0xb0,
0x94, 0x00, 0x9a, 0xa6, 0xae, 0xef, 0xc0, 0x1c, 0x75, 0xf7, 0xbc, 0xc1, 0x94, 0xf3, 0xaa, 0x6a,
0xca, 0x89, 0x83, 0x85, 0xda, 0x57, 0xf7, 0xa1, 0x98, 0x9c, 0x7d, 0x50, 0x01, 0x16, 0xb6, 0x3d,
0x7e, 0xeb, 0x19, 0x65, 0xbc, 0x3c, 0x83, 0x8a, 0x00, 0xdb, 0x1e, 0xdf, 0xf1, 0x09, 0x23, 0x2e,
0x2f, 0x6b, 0x08, 0x20, 0xf7, 0x89, 0x5b, 0xa3, 0xec, 0x51, 0x79, 0x16, 0x2d, 0xc9, 0x91, 0xd6,
0xec, 0xd6, 0xdd, 0x3b, 0xc4, 0xf1, 0xfc, 0xe7, 0xe5, 0x4c, 0x70, 0x3d, 0x3a, 0x65, 0x51, 0x19,
0x0a, 0x91, 0xca, 0xed, 0x9d, 0x7b, 0xe5, 0x39, 0x94, 0x87, 0xb9, 0xf0, 0x67, 0x6e, 0xf3, 0x3b,
0x80, 0x82, 0x78, 0x6d, 0x1a, 0xe1, 0x76, 0x8d, 0x2c, 0x28, 0xc4, 0xf7, 0x58, 0x74, 0x59, 0x15,
0x84, 0x62, 0xd7, 0xd6, 0xd7, 0xc7, 0x2b, 0x86, 0xb9, 0xc5, 0x33, 0xe8, 0x21, 0x94, 0x92, 0xcb,
0x23, 0x43, 0x57, 0x94, 0xc9, 0x52, 0x2d, 0xb0, 0xfa, 0xd5, 0x49, 0x54, 0x23, 0xac, 0x36, 0x14,
0x13, 0x6b, 0x06, 0x43, 0xeb, 0xa3, 0xee, 0xa7, 0x27, 0x2d, 0xfd, 0xca, 0x04, 0x9a, 0x11, 0xd0,
0x67, 0x50, 0x4c, 0xcc, 0xa5, 0x23, 0x80, 0x54, 0xb3, 0xab, 0x7e, 0x58, 0x7b, 0xe1, 0x19, 0xd4,
0x84, 0xb3, 0xe9, 0x61, 0x90, 0xa1, 0x6b, 0xea, 0x84, 0x2b, 0x67, 0xc6, 0x71, 0x00, 0xbb, 0xa1,
0xef, 0x07, 0x09, 0x54, 0xd7, 0x43, 0xb9, 0x7b, 0x8f, 0xb3, 0xfd, 0x65, 0xe4, 0x7c, 0xcc, 0xfc,
0x9b, 0x87, 0x38, 0x7f, 0x64, 0x84, 0x16, 0xa0, 0xe1, 0x09, 0x14, 0xe9, 0xca, 0x4b, 0xb7, 0x9c,
0x1e, 0x7f, 0xae, 0x57, 0x55, 0xf0, 0xa3, 0xa7, 0x58, 0x3c, 0x83, 0xee, 0x03, 0xba, 0x4d, 0xf8,
0x5d, 0xea, 0x90, 0xbb, 0xd4, 0x7a, 0x34, 0x09, 0x46, 0xea, 0x35, 0x96, 0x87, 0x06, 0xf7, 0xa9,
0xdb, 0x4e, 0xb4, 0xcd, 0xf2, 0x6d, 0x22, 0x18, 0x9e, 0x32, 0x4e, 0x2d, 0xf6, 0x02, 0x4d, 0x7b,
0xc2, 0xe7, 0xf4, 0xca, 0x7b, 0x75, 0x92, 0xe5, 0x4b, 0x26, 0xfe, 0xda, 0x44, 0xba, 0x11, 0xe0,
0xae, 0x00, 0x4c, 0x3d, 0x5b, 0x87, 0x46, 0x32, 0xe1, 0xd3, 0x87, 0x67, 0x90, 0x05, 0xc5, 0x20,
0x4f, 0xb1, 0x67, 0xef, 0xd2, 0x38, 0x7e, 0x95, 0x41, 0x5c, 0x1e, 0xab, 0x37, 0x08, 0x60, 0xf3,
0xc7, 0x05, 0xc8, 0x8b, 0x06, 0x10, 0xdc, 0x77, 0x62, 0x35, 0xbf, 0x0b, 0x25, 0x59, 0xf3, 0x17,
0x59, 0xee, 0xe6, 0x91, 0xb3, 0xaf, 0x2c, 0xef, 0x88, 0x51, 0x07, 0xcf, 0xa0, 0x07, 0x50, 0x4a,
0x6d, 0x51, 0x6a, 0x12, 0x1a, 0xb1, 0x6a, 0x8d, 0xfb, 0x8c, 0x2d, 0x40, 0xc3, 0xeb, 0x0f, 0xaa,
0xaa, 0x99, 0x62, 0xd4, 0x9a, 0x34, 0x0e, 0xe4, 0x0b, 0x28, 0xa5, 0xd6, 0x10, 0xf5, 0x07, 0xa1,
0xde, 0x55, 0xc6, 0x59, 0xbf, 0x07, 0x85, 0xd8, 0xde, 0xc1, 0xd4, 0x2d, 0x3a, 0xbc, 0x99, 0x9c,
0x3e, 0x85, 0x9e, 0xf8, 0x0b, 0xf3, 0x39, 0x94, 0x92, 0x7b, 0xc2, 0x88, 0x27, 0x5f, 0xb9, 0x4c,
0x8c, 0xef, 0x9c, 0x93, 0xe7, 0x86, 0x9b, 0x37, 0x76, 0x3f, 0x6c, 0x53, 0xde, 0xe9, 0xb7, 0x02,
0xf8, 0x8d, 0x7d, 0xda, 0xed, 0xd2, 0x7d, 0x4e, 0xac, 0xce, 0x46, 0x68, 0xe1, 0x2d, 0x9b, 0x32,
0xee, 0xd3, 0x56, 0x9f, 0x13, 0x7b, 0x63, 0xc0, 0x63, 0x1b, 0xc2, 0xec, 0x86, 0x30, 0xdb, 0x6b,
0xb5, 0x72, 0xe2, 0x78, 0xfd, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb4, 0xe5, 0x98, 0xdb, 0x26,
0x19, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2032,6 +2033,8 @@ type QueryNodeClient interface {
RemoveQueryChannel(ctx context.Context, in *RemoveQueryChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
WatchDmChannels(ctx context.Context, in *WatchDmChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
LoadSegments(ctx context.Context, in *LoadSegmentRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleaseCollection(ctx context.Context, in *ReleaseCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleasePartitions(ctx context.Context, in *ReleasePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleaseSegments(ctx context.Context, in *ReleaseSegmentRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
GetSegmentInfo(ctx context.Context, in *SegmentInfoRequest, opts ...grpc.CallOption) (*SegmentInfoResponse, error)
}
@ -2107,6 +2110,24 @@ func (c *queryNodeClient) LoadSegments(ctx context.Context, in *LoadSegmentReque
return out, nil
}
func (c *queryNodeClient) ReleaseCollection(ctx context.Context, in *ReleaseCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/ReleaseCollection", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *queryNodeClient) ReleasePartitions(ctx context.Context, in *ReleasePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/ReleasePartitions", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *queryNodeClient) ReleaseSegments(ctx context.Context, in *ReleaseSegmentRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/ReleaseSegments", in, out, opts...)
@ -2134,6 +2155,8 @@ type QueryNodeServer interface {
RemoveQueryChannel(context.Context, *RemoveQueryChannelsRequest) (*commonpb.Status, error)
WatchDmChannels(context.Context, *WatchDmChannelsRequest) (*commonpb.Status, error)
LoadSegments(context.Context, *LoadSegmentRequest) (*commonpb.Status, error)
ReleaseCollection(context.Context, *ReleaseCollectionRequest) (*commonpb.Status, error)
ReleasePartitions(context.Context, *ReleasePartitionRequest) (*commonpb.Status, error)
ReleaseSegments(context.Context, *ReleaseSegmentRequest) (*commonpb.Status, error)
GetSegmentInfo(context.Context, *SegmentInfoRequest) (*SegmentInfoResponse, error)
}
@ -2163,6 +2186,12 @@ func (*UnimplementedQueryNodeServer) WatchDmChannels(ctx context.Context, req *W
func (*UnimplementedQueryNodeServer) LoadSegments(ctx context.Context, req *LoadSegmentRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method LoadSegments not implemented")
}
func (*UnimplementedQueryNodeServer) ReleaseCollection(ctx context.Context, req *ReleaseCollectionRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method ReleaseCollection not implemented")
}
func (*UnimplementedQueryNodeServer) ReleasePartitions(ctx context.Context, req *ReleasePartitionRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method ReleasePartitions not implemented")
}
func (*UnimplementedQueryNodeServer) ReleaseSegments(ctx context.Context, req *ReleaseSegmentRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method ReleaseSegments not implemented")
}
@ -2300,6 +2329,42 @@ func _QueryNode_LoadSegments_Handler(srv interface{}, ctx context.Context, dec f
return interceptor(ctx, in, info, handler)
}
func _QueryNode_ReleaseCollection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReleaseCollectionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryNodeServer).ReleaseCollection(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.query.QueryNode/ReleaseCollection",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryNodeServer).ReleaseCollection(ctx, req.(*ReleaseCollectionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _QueryNode_ReleasePartitions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReleasePartitionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryNodeServer).ReleasePartitions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.query.QueryNode/ReleasePartitions",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryNodeServer).ReleasePartitions(ctx, req.(*ReleasePartitionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _QueryNode_ReleaseSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReleaseSegmentRequest)
if err := dec(in); err != nil {
@ -2368,6 +2433,14 @@ var _QueryNode_serviceDesc = grpc.ServiceDesc{
MethodName: "LoadSegments",
Handler: _QueryNode_LoadSegments_Handler,
},
{
MethodName: "ReleaseCollection",
Handler: _QueryNode_ReleaseCollection_Handler,
},
{
MethodName: "ReleasePartitions",
Handler: _QueryNode_ReleasePartitions_Handler,
},
{
MethodName: "ReleaseSegments",
Handler: _QueryNode_ReleaseSegments_Handler,

2
internal/proxynode/task.go
View File

@ -555,7 +555,7 @@ func (st *SearchTask) PreExecute(ctx context.Context) error {
for _, partitionName := range st.query.PartitionNames {
partitionID, err := globalMetaCache.GetPartitionID(collectionName, partitionName)
if err != nil {
return err
continue
}
st.PartitionIDs = append(st.PartitionIDs, partitionID)
}

15
internal/querynode/collection_replica.go
View File

@ -12,6 +12,7 @@ package querynode
*/
import "C"
import (
"fmt"
"strconv"
"sync"
@ -114,15 +115,15 @@ func (colReplica *collectionReplicaImpl) removeCollectionPrivate(collectionID Un
return err
}
deleteCollection(collection)
delete(colReplica.collections, collectionID)
// delete partitions
for _, partitionID := range collection.partitionIDs {
// ignore error, try to delete
_ = colReplica.removePartitionPrivate(partitionID)
}
deleteCollection(collection)
delete(colReplica.collections, collectionID)
return nil
}
@ -262,14 +263,15 @@ func (colReplica *collectionReplicaImpl) removePartitionPrivate(partitionID Uniq
return err
}
collection.removePartitionID(partitionID)
delete(colReplica.partitions, partitionID)
// delete segments
for _, segmentID := range partition.segmentIDs {
// try to delete, ignore error
_ = colReplica.removeSegmentPrivate(segmentID)
}
collection.removePartitionID(partitionID)
delete(colReplica.partitions, partitionID)
return nil
}
@ -390,6 +392,7 @@ func (colReplica *collectionReplicaImpl) removeSegment(segmentID UniqueID) error
}
func (colReplica *collectionReplicaImpl) removeSegmentPrivate(segmentID UniqueID) error {
fmt.Println("remove segment", segmentID)
segment, err := colReplica.getSegmentByIDPrivate(segmentID)
if err != nil {
return err

2
internal/querynode/flow_graph_dd_node.go
View File

@ -20,7 +20,7 @@ func (ddNode *ddNode) Name() string {
}
func (ddNode *ddNode) Operate(in []*Msg) []*Msg {
//fmt.Println("Do filterDmNode operation")
//fmt.Println("Do ddNode operation")
if len(in) != 1 {
log.Println("Invalid operate message input in ddNode, input length = ", len(in))

2
internal/querynode/partition.go
View File

@ -11,6 +11,7 @@ package querynode
*/
import "C"
import "fmt"
type Partition struct {
collectionID UniqueID
@ -44,5 +45,6 @@ func newPartition(collectionID UniqueID, partitionID UniqueID) *Partition {
enable: false,
}
fmt.Println("create partition", partitionID)
return newPartition
}

59
internal/querynode/query_node.go
View File

@ -38,6 +38,8 @@ type Node interface {
RemoveQueryChannel(in *queryPb.RemoveQueryChannelsRequest) (*commonpb.Status, error)
WatchDmChannels(in *queryPb.WatchDmChannelsRequest) (*commonpb.Status, error)
LoadSegments(in *queryPb.LoadSegmentRequest) (*commonpb.Status, error)
ReleaseCollection(in *queryPb.ReleaseCollectionRequest) (*commonpb.Status, error)
ReleasePartitions(in *queryPb.ReleasePartitionRequest) (*commonpb.Status, error)
ReleaseSegments(in *queryPb.ReleaseSegmentRequest) (*commonpb.Status, error)
GetSegmentInfo(in *queryPb.SegmentInfoRequest) (*queryPb.SegmentInfoResponse, error)
}
@ -479,34 +481,51 @@ func (node *QueryNode) LoadSegments(in *queryPb.LoadSegmentRequest) (*commonpb.S
}, nil
}
func (node *QueryNode) ReleaseSegments(in *queryPb.ReleaseSegmentRequest) (*commonpb.Status, error) {
for _, id := range in.PartitionIDs {
err := node.replica.enablePartition(id)
if err != nil {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
}
return status, err
func (node *QueryNode) ReleaseCollection(in *queryPb.ReleaseCollectionRequest) (*commonpb.Status, error) {
err := node.replica.removeCollection(in.CollectionID)
if err != nil {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
}
return status, err
}
// release all fields in the segments
for _, id := range in.SegmentIDs {
err := node.loadService.segLoader.releaseSegment(id)
if err != nil {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
}
return status, err
}
}
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
}, nil
}
func (node *QueryNode) ReleasePartitions(in *queryPb.ReleasePartitionRequest) (*commonpb.Status, error) {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
}
for _, id := range in.PartitionIDs {
err := node.loadService.segLoader.replica.removePartition(id)
if err != nil {
// not return, try to release all partitions
status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR
status.Reason = err.Error()
}
}
return status, nil
}
func (node *QueryNode) ReleaseSegments(in *queryPb.ReleaseSegmentRequest) (*commonpb.Status, error) {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
}
for _, id := range in.SegmentIDs {
err2 := node.loadService.segLoader.replica.removeSegment(id)
if err2 != nil {
// not return, try to release all segments
status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR
status.Reason = err2.Error()
}
}
return status, nil
}
func (node *QueryNode) GetSegmentInfo(in *queryPb.SegmentInfoRequest) (*queryPb.SegmentInfoResponse, error) {
infos := make([]*queryPb.SegmentInfo, 0)
for _, id := range in.SegmentIDs {

5
internal/querynode/segment_loader.go
View File

@ -28,11 +28,6 @@ type segmentLoader struct {
indexLoader *indexLoader
}
func (loader *segmentLoader) releaseSegment(segmentID UniqueID) error {
err := loader.replica.removeSegment(segmentID)
return err
}
func (loader *segmentLoader) seekSegment(position *internalpb2.MsgPosition) error {
// TODO: open seek
//for _, position := range positions {

8
internal/queryservice/querynode.go
View File

@ -36,6 +36,14 @@ func (qn *queryNodeInfo) AddQueryChannel(in *querypb.AddQueryChannelsRequest) (*
return qn.client.AddQueryChannel(in)
}
func (qn *queryNodeInfo) ReleaseCollection(in *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
return qn.client.ReleaseCollection(in)
}
func (qn *queryNodeInfo) ReleasePartitions(in *querypb.ReleasePartitionRequest) (*commonpb.Status, error) {
return qn.client.ReleasePartitions(in)
}
func newQueryNodeInfo(client QueryNodeInterface) *queryNodeInfo {
segments := make([]UniqueID, 0)
dmChannelNames := make([]string, 0)

73
internal/queryservice/queryservice.go
View File

@ -40,6 +40,8 @@ type QueryNodeInterface interface {
RemoveQueryChannel(in *querypb.RemoveQueryChannelsRequest) (*commonpb.Status, error)
WatchDmChannels(in *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)
LoadSegments(in *querypb.LoadSegmentRequest) (*commonpb.Status, error)
ReleaseCollection(req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)
ReleasePartitions(req *querypb.ReleasePartitionRequest) (*commonpb.Status, error)
ReleaseSegments(in *querypb.ReleaseSegmentRequest) (*commonpb.Status, error)
GetSegmentInfo(req *querypb.SegmentInfoRequest) (*querypb.SegmentInfoResponse, error)
}
@ -278,7 +280,7 @@ func (qs *QueryService) ReleaseCollection(req *querypb.ReleaseCollectionRequest)
dbID := req.DbID
collectionID := req.CollectionID
fmt.Println("release collection start, collectionID = ", collectionID)
partitions, err := qs.replica.getPartitions(dbID, collectionID)
_, err := qs.replica.getCollectionByID(dbID, collectionID)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
@ -286,20 +288,13 @@ func (qs *QueryService) ReleaseCollection(req *querypb.ReleaseCollectionRequest)
}, err
}
partitionIDs := make([]UniqueID, 0)
for _, partition := range partitions {
partitionIDs = append(partitionIDs, partition.id)
for _, node := range qs.queryNodes {
status, err := node.ReleaseCollection(req)
if err != nil {
return status, err
}
}
releasePartitionRequest := &querypb.ReleasePartitionRequest{
Base: req.Base,
DbID: dbID,
CollectionID: collectionID,
PartitionIDs: partitionIDs,
}
status, err := qs.ReleasePartitions(releasePartitionRequest)
err = qs.replica.releaseCollection(dbID, collectionID)
if err != nil {
return &commonpb.Status{
@ -310,7 +305,9 @@ func (qs *QueryService) ReleaseCollection(req *querypb.ReleaseCollectionRequest)
fmt.Println("release collection end")
//TODO:: queryNode cancel subscribe dmChannels
return status, err
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
}, nil
}
func (qs *QueryService) ShowPartitions(req *querypb.ShowPartitionRequest) (*querypb.ShowPartitionResponse, error) {
@ -475,48 +472,34 @@ func (qs *QueryService) ReleasePartitions(req *querypb.ReleasePartitionRequest)
dbID := req.DbID
collectionID := req.CollectionID
partitionIDs := req.PartitionIDs
segmentIDs := make([]UniqueID, 0)
fmt.Println("start release partitions start, partitionIDs = ", partitionIDs)
toReleasedPartitionID := make([]UniqueID, 0)
for _, partitionID := range partitionIDs {
showSegmentRequest := &milvuspb.ShowSegmentRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kShowSegment,
},
CollectionID: collectionID,
PartitionID: partitionID,
}
showSegmentResponse, err := qs.masterServiceClient.ShowSegments(showSegmentRequest)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
}, err
_, err := qs.replica.getPartitionByID(dbID, collectionID, partitionID)
if err == nil {
toReleasedPartitionID = append(toReleasedPartitionID, partitionID)
}
}
segmentIDs = append(segmentIDs, showSegmentResponse.SegmentIDs...)
err = qs.replica.releasePartition(dbID, collectionID, partitionID)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
}, err
}
}
releaseSegmentRequest := &querypb.ReleaseSegmentRequest{
Base: req.Base,
DbID: dbID,
CollectionID: collectionID,
PartitionIDs: partitionIDs,
SegmentIDs: segmentIDs,
}
req.PartitionIDs = toReleasedPartitionID
for _, node := range qs.queryNodes {
status, err := node.client.ReleaseSegments(releaseSegmentRequest)
status, err := node.client.ReleasePartitions(req)
if err != nil {
return status, err
}
}
for _, partitionID := range toReleasedPartitionID {
err := qs.replica.releasePartition(dbID, collectionID, partitionID)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
}, err
}
}
fmt.Println("start release partitions end")
//TODO:: queryNode cancel subscribe dmChannels
return &commonpb.Status{