From 8bdbc4379ea31a68b55535bb0e32bbd22d459228 Mon Sep 17 00:00:00 2001 From: aoiasd <45024769+aoiasd@users.noreply.github.com> Date: Thu, 4 Dec 2025 10:41:11 +0800 Subject: [PATCH] feat: [2.6] Support search with highlighter (#46052) relate: https://github.com/milvus-io/milvus/issues/42589 pr: https://github.com/milvus-io/milvus/pull/45736 https://github.com/milvus-io/milvus/pull/45099 https://github.com/milvus-io/milvus/pull/44923 https://github.com/milvus-io/milvus/pull/45984 --------- Signed-off-by: aoiasd --- go.mod | 2 +- go.sum | 4 +- .../distributed/querynode/client/client.go | 11 + .../querynode/client/client_test.go | 6 + internal/distributed/querynode/service.go | 4 + .../distributed/querynode/service_test.go | 22 + internal/mocks/mock_querynode.go | 59 + internal/mocks/mock_querynode_client.go | 74 + internal/proxy/highlighter.go | 403 ++++ internal/proxy/search_pipeline.go | 93 +- internal/proxy/search_pipeline_test.go | 105 + internal/proxy/task.go | 91 + internal/proxy/task_search.go | 91 +- internal/proxy/task_search_test.go | 195 ++ internal/proxy/task_test.go | 235 +++ internal/proxy/util.go | 6 + internal/querycoordv2/mocks/mock_querynode.go | 59 + internal/querynodev2/delegator/delegator.go | 1 + .../querynodev2/delegator/delegator_data.go | 85 + .../querynodev2/delegator/delegator_test.go | 153 ++ .../querynodev2/delegator/mock_delegator.go | 59 + internal/querynodev2/delegator/util.go | 119 ++ internal/querynodev2/delegator/util_test.go | 38 + internal/querynodev2/services.go | 33 + internal/querynodev2/services_test.go | 43 + internal/util/mock/grpc_querynode_client.go | 4 + internal/util/wrappers/qn_wrapper.go | 4 + pkg/go.mod | 2 +- pkg/go.sum | 4 +- pkg/proto/query_coord.proto | 59 + pkg/proto/querypb/query_coord.pb.go | 1762 ++++++++++++----- pkg/proto/querypb/query_coord_grpc.pb.go | 37 + 32 files changed, 3263 insertions(+), 600 deletions(-) create mode 100644 internal/proxy/highlighter.go create mode 100644 internal/querynodev2/delegator/util_test.go diff --git a/go.mod b/go.mod index 06919558cd..4cf20f5c08 100644 --- a/go.mod +++ b/go.mod @@ -21,7 +21,7 @@ require ( github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 github.com/klauspost/compress v1.18.0 github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d - github.com/milvus-io/milvus-proto/go-api/v2 v2.6.7 + github.com/milvus-io/milvus-proto/go-api/v2 v2.6.8-0.20251203092105-e2557263fc4c github.com/minio/minio-go/v7 v7.0.73 github.com/panjf2000/ants/v2 v2.11.3 // indirect github.com/pingcap/log v1.1.1-0.20221015072633-39906604fb81 // indirect diff --git a/go.sum b/go.sum index 0e27c7472a..a1d70cb72f 100644 --- a/go.sum +++ b/go.sum @@ -799,8 +799,8 @@ github.com/milvus-io/cgosymbolizer v0.0.0-20250318084424-114f4050c3a6 h1:YHMFI6L github.com/milvus-io/cgosymbolizer v0.0.0-20250318084424-114f4050c3a6/go.mod h1:DvXTE/K/RtHehxU8/GtDs4vFtfw64jJ3PaCnFri8CRg= github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b h1:TfeY0NxYxZzUfIfYe5qYDBzt4ZYRqzUjTR6CvUzjat8= github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b/go.mod h1:iwW+9cWfIzzDseEBCCeDSN5SD16Tidvy8cwQ7ZY8Qj4= -github.com/milvus-io/milvus-proto/go-api/v2 v2.6.7 h1:RJtZbkS5zKNIXxsqjGBUZc2SbnI4MGq+TfOfc8tJsuM= -github.com/milvus-io/milvus-proto/go-api/v2 v2.6.7/go.mod h1:/6UT4zZl6awVeXLeE7UGDWZvXj3IWkRsh3mqsn0DiAs= +github.com/milvus-io/milvus-proto/go-api/v2 v2.6.8-0.20251203092105-e2557263fc4c h1:Gh02wIJEI6RUbEXwZworPBfK9BYd1SVBIDHDL8GsrCY= +github.com/milvus-io/milvus-proto/go-api/v2 v2.6.8-0.20251203092105-e2557263fc4c/go.mod h1:/6UT4zZl6awVeXLeE7UGDWZvXj3IWkRsh3mqsn0DiAs= github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 h1:AMFGa4R4MiIpspGNG7Z948v4n35fFGB3RR3G/ry4FWs= github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY= github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3 h1:+n/aFZefKZp7spd8DFdX7uMikMLXX4oubIzJF4kv/wI= diff --git a/internal/distributed/querynode/client/client.go b/internal/distributed/querynode/client/client.go index cc5a0adb01..ecb1c9f2eb 100644 --- a/internal/distributed/querynode/client/client.go +++ b/internal/distributed/querynode/client/client.go @@ -394,3 +394,14 @@ func (c *Client) DropIndex(ctx context.Context, req *querypb.DropIndexRequest, _ return client.DropIndex(ctx, req) }) } + +func (c *Client) GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest, _ ...grpc.CallOption) (*querypb.GetHighlightResponse, error) { + req = typeutil.Clone(req) + commonpbutil.UpdateMsgBase( + req.GetBase(), + commonpbutil.FillMsgBaseFromClient(c.nodeID), + ) + return wrapGrpcCall(ctx, c, func(client querypb.QueryNodeClient) (*querypb.GetHighlightResponse, error) { + return client.GetHighlight(ctx, req) + }) +} diff --git a/internal/distributed/querynode/client/client_test.go b/internal/distributed/querynode/client/client_test.go index 1062b516ac..62d45d5139 100644 --- a/internal/distributed/querynode/client/client_test.go +++ b/internal/distributed/querynode/client/client_test.go @@ -111,6 +111,12 @@ func Test_NewClient(t *testing.T) { r21, err := client.DeleteBatch(ctx, nil) retCheck(retNotNil, r21, err) + r22, err := client.RunAnalyzer(ctx, nil) + retCheck(retNotNil, r22, err) + + r24, err := client.GetHighlight(ctx, nil) + retCheck(retNotNil, r24, err) + // stream rpc client, err := client.QueryStream(ctx, nil) retCheck(retNotNil, client, err) diff --git a/internal/distributed/querynode/service.go b/internal/distributed/querynode/service.go index d2c7906c00..b2b40f4882 100644 --- a/internal/distributed/querynode/service.go +++ b/internal/distributed/querynode/service.go @@ -407,3 +407,7 @@ func (s *Server) RunAnalyzer(ctx context.Context, req *querypb.RunAnalyzerReques func (s *Server) DropIndex(ctx context.Context, req *querypb.DropIndexRequest) (*commonpb.Status, error) { return s.querynode.DropIndex(ctx, req) } + +func (s *Server) GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error) { + return s.querynode.GetHighlight(ctx, req) +} diff --git a/internal/distributed/querynode/service_test.go b/internal/distributed/querynode/service_test.go index 4e9546adeb..e7c955e352 100644 --- a/internal/distributed/querynode/service_test.go +++ b/internal/distributed/querynode/service_test.go @@ -280,6 +280,28 @@ func Test_NewServer(t *testing.T) { assert.NoError(t, merr.CheckRPCCall(resp, err)) }) + t.Run("RunAnalyzer", func(t *testing.T) { + mockQN.EXPECT().RunAnalyzer(mock.Anything, mock.Anything).Return(&milvuspb.RunAnalyzerResponse{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, + }, nil) + req := &querypb.RunAnalyzerRequest{} + resp, err := server.RunAnalyzer(ctx, req) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode()) + }) + + t.Run("GetHighlight", func(t *testing.T) { + mockQN.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return(&querypb.GetHighlightResponse{ + Status: merr.Success(), + }, nil) + + resp, err := server.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Channel: "test-channel", + }) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode()) + }) + err = server.Stop() assert.NoError(t, err) } diff --git a/internal/mocks/mock_querynode.go b/internal/mocks/mock_querynode.go index c344ec0c99..b244965e7f 100644 --- a/internal/mocks/mock_querynode.go +++ b/internal/mocks/mock_querynode.go @@ -370,6 +370,65 @@ func (_c *MockQueryNode_GetDataDistribution_Call) RunAndReturn(run func(context. return _c } +// GetHighlight provides a mock function with given fields: _a0, _a1 +func (_m *MockQueryNode) GetHighlight(_a0 context.Context, _a1 *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetHighlight") + } + + var r0 *querypb.GetHighlightResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest) *querypb.GetHighlightResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*querypb.GetHighlightResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetHighlightRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNode_GetHighlight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHighlight' +type MockQueryNode_GetHighlight_Call struct { + *mock.Call +} + +// GetHighlight is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *querypb.GetHighlightRequest +func (_e *MockQueryNode_Expecter) GetHighlight(_a0 interface{}, _a1 interface{}) *MockQueryNode_GetHighlight_Call { + return &MockQueryNode_GetHighlight_Call{Call: _e.mock.On("GetHighlight", _a0, _a1)} +} + +func (_c *MockQueryNode_GetHighlight_Call) Run(run func(_a0 context.Context, _a1 *querypb.GetHighlightRequest)) *MockQueryNode_GetHighlight_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.GetHighlightRequest)) + }) + return _c +} + +func (_c *MockQueryNode_GetHighlight_Call) Return(_a0 *querypb.GetHighlightResponse, _a1 error) *MockQueryNode_GetHighlight_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNode_GetHighlight_Call) RunAndReturn(run func(context.Context, *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error)) *MockQueryNode_GetHighlight_Call { + _c.Call.Return(run) + return _c +} + // GetMetrics provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNode) GetMetrics(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { ret := _m.Called(_a0, _a1) diff --git a/internal/mocks/mock_querynode_client.go b/internal/mocks/mock_querynode_client.go index 093716cf67..70bd72c84f 100644 --- a/internal/mocks/mock_querynode_client.go +++ b/internal/mocks/mock_querynode_client.go @@ -446,6 +446,80 @@ func (_c *MockQueryNodeClient_GetDataDistribution_Call) RunAndReturn(run func(co return _c } +// GetHighlight provides a mock function with given fields: ctx, in, opts +func (_m *MockQueryNodeClient) GetHighlight(ctx context.Context, in *querypb.GetHighlightRequest, opts ...grpc.CallOption) (*querypb.GetHighlightResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetHighlight") + } + + var r0 *querypb.GetHighlightResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest, ...grpc.CallOption) (*querypb.GetHighlightResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest, ...grpc.CallOption) *querypb.GetHighlightResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*querypb.GetHighlightResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetHighlightRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNodeClient_GetHighlight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHighlight' +type MockQueryNodeClient_GetHighlight_Call struct { + *mock.Call +} + +// GetHighlight is a helper method to define mock.On call +// - ctx context.Context +// - in *querypb.GetHighlightRequest +// - opts ...grpc.CallOption +func (_e *MockQueryNodeClient_Expecter) GetHighlight(ctx interface{}, in interface{}, opts ...interface{}) *MockQueryNodeClient_GetHighlight_Call { + return &MockQueryNodeClient_GetHighlight_Call{Call: _e.mock.On("GetHighlight", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockQueryNodeClient_GetHighlight_Call) Run(run func(ctx context.Context, in *querypb.GetHighlightRequest, opts ...grpc.CallOption)) *MockQueryNodeClient_GetHighlight_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*querypb.GetHighlightRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockQueryNodeClient_GetHighlight_Call) Return(_a0 *querypb.GetHighlightResponse, _a1 error) *MockQueryNodeClient_GetHighlight_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNodeClient_GetHighlight_Call) RunAndReturn(run func(context.Context, *querypb.GetHighlightRequest, ...grpc.CallOption) (*querypb.GetHighlightResponse, error)) *MockQueryNodeClient_GetHighlight_Call { + _c.Call.Return(run) + return _c +} + // GetMetrics provides a mock function with given fields: ctx, in, opts func (_m *MockQueryNodeClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) { _va := make([]interface{}, len(opts)) diff --git a/internal/proxy/highlighter.go b/internal/proxy/highlighter.go new file mode 100644 index 0000000000..38f9b830ae --- /dev/null +++ b/internal/proxy/highlighter.go @@ -0,0 +1,403 @@ +package proxy + +import ( + "context" + "encoding/json" + "strconv" + "strings" + + "github.com/cockroachdb/errors" + "github.com/samber/lo" + "go.opentelemetry.io/otel/trace" + + "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" + "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" + "github.com/milvus-io/milvus/internal/proxy/shardclient" + "github.com/milvus-io/milvus/pkg/v2/proto/querypb" + "github.com/milvus-io/milvus/pkg/v2/util/funcutil" + "github.com/milvus-io/milvus/pkg/v2/util/merr" + "github.com/milvus-io/milvus/pkg/v2/util/typeutil" +) + +const ( + PreTagsKey = "pre_tags" + PostTagsKey = "post_tags" + HighlightSearchTextKey = "highlight_search_text" + HighlightQueryKey = "queries" + FragmentOffsetKey = "fragment_offset" + FragmentSizeKey = "fragment_size" + FragmentNumKey = "num_of_fragments" + DefaultFragmentSize = 100 + DefaultFragmentNum = 5 + DefaultPreTag = "" + DefaultPostTag = "" +) + +type Highlighter interface { + AsSearchPipelineOperator(t *searchTask) (operator, error) + FieldIDs() []int64 +} + +// highlight task for one field +type highlightTask struct { + *querypb.HighlightTask + preTags [][]byte + postTags [][]byte +} + +type highlightQuery struct { + text string + fieldName string + highlightType querypb.HighlightQueryType +} + +type LexicalHighlighter struct { + tasks map[int64]*highlightTask // fieldID -> highlightTask + // option for all highlight task + // TODO: support set option for each task + preTags [][]byte + postTags [][]byte + highlightSearch bool + options *querypb.HighlightOptions + queries []*highlightQuery +} + +// add highlight task with search +// must used before addTaskWithQuery +func (h *LexicalHighlighter) addTaskWithSearchText(fieldID int64, fieldName string, analyzerName string, texts []string) error { + _, ok := h.tasks[fieldID] + if ok { + return merr.WrapErrParameterInvalidMsg("not support hybrid search with highlight now. fieldID: %d", fieldID) + } + + task := &highlightTask{ + preTags: h.preTags, + postTags: h.postTags, + HighlightTask: &querypb.HighlightTask{ + FieldName: fieldName, + FieldId: fieldID, + Options: h.options, + }, + } + h.tasks[fieldID] = task + + task.Texts = texts + task.SearchTextNum = int64(len(texts)) + if analyzerName != "" { + task.AnalyzerNames = []string{} + for i := 0; i < len(texts); i++ { + task.AnalyzerNames = append(task.AnalyzerNames, analyzerName) + } + } + return nil +} + +func (h *LexicalHighlighter) addTaskWithQuery(fieldID int64, query *highlightQuery) { + task, ok := h.tasks[fieldID] + if !ok { + task = &highlightTask{ + HighlightTask: &querypb.HighlightTask{ + Texts: []string{}, + FieldId: fieldID, + FieldName: query.fieldName, + Options: h.options, + }, + preTags: h.preTags, + postTags: h.postTags, + } + h.tasks[fieldID] = task + } + + task.Texts = append(task.Texts, query.text) + task.Queries = append(task.Queries, &querypb.HighlightQuery{ + Type: query.highlightType, + }) +} + +func (h *LexicalHighlighter) initHighlightQueries(t *searchTask) error { + // add query to highlight tasks + for _, query := range h.queries { + fieldID, ok := t.schema.MapFieldID(query.fieldName) + if !ok { + return merr.WrapErrParameterInvalidMsg("highlight field not found in schema: %s", query.fieldName) + } + h.addTaskWithQuery(fieldID, query) + } + return nil +} + +func (h *LexicalHighlighter) AsSearchPipelineOperator(t *searchTask) (operator, error) { + return newLexicalHighlightOperator(t, lo.Values(h.tasks)) +} + +func (h *LexicalHighlighter) FieldIDs() []int64 { + return lo.Keys(h.tasks) +} + +func NewLexicalHighlighter(highlighter *commonpb.Highlighter) (*LexicalHighlighter, error) { + params := funcutil.KeyValuePair2Map(highlighter.GetParams()) + h := &LexicalHighlighter{ + tasks: make(map[int64]*highlightTask), + options: &querypb.HighlightOptions{}, + } + + // set pre_tags and post_tags + if value, ok := params[PreTagsKey]; ok { + tags := []string{} + if err := json.Unmarshal([]byte(value), &tags); err != nil { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal pre_tags as string array failed: %v", err) + } + if len(tags) == 0 { + return nil, merr.WrapErrParameterInvalidMsg("pre_tags cannot be empty list") + } + + h.preTags = make([][]byte, len(tags)) + for i, tag := range tags { + h.preTags[i] = []byte(tag) + } + } else { + h.preTags = [][]byte{[]byte(DefaultPreTag)} + } + + if value, ok := params[PostTagsKey]; ok { + tags := []string{} + if err := json.Unmarshal([]byte(value), &tags); err != nil { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal post_tags as string list failed: %v", err) + } + if len(tags) == 0 { + return nil, merr.WrapErrParameterInvalidMsg("post_tags cannot be empty list") + } + h.postTags = make([][]byte, len(tags)) + for i, tag := range tags { + h.postTags[i] = []byte(tag) + } + } else { + h.postTags = [][]byte{[]byte(DefaultPostTag)} + } + + // set fragment config + if value, ok := params[FragmentSizeKey]; ok { + fragmentSize, err := strconv.ParseInt(value, 10, 64) + if err != nil || fragmentSize <= 0 { + return nil, merr.WrapErrParameterInvalidMsg("invalid fragment_size: %s", value) + } + h.options.FragmentSize = fragmentSize + } else { + h.options.FragmentSize = DefaultFragmentSize + } + + if value, ok := params[FragmentNumKey]; ok { + fragmentNum, err := strconv.ParseInt(value, 10, 64) + if err != nil || fragmentNum < 0 { + return nil, merr.WrapErrParameterInvalidMsg("invalid num_of_fragments: %s", value) + } + h.options.NumOfFragments = fragmentNum + } else { + h.options.NumOfFragments = DefaultFragmentNum + } + + if value, ok := params[FragmentOffsetKey]; ok { + fragmentOffset, err := strconv.ParseInt(value, 10, 64) + if err != nil || fragmentOffset < 0 { + return nil, merr.WrapErrParameterInvalidMsg("invalid fragment_offset: %s", value) + } + h.options.FragmentOffset = fragmentOffset + } + + if value, ok := params[HighlightSearchTextKey]; ok { + enable, err := strconv.ParseBool(value) + if err != nil { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight_search_text as bool failed: %v", err) + } + + h.highlightSearch = enable + } + + if value, ok := params[HighlightQueryKey]; ok { + queries := []any{} + if err := json.Unmarshal([]byte(value), &queries); err != nil { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries as json array failed: %v", err) + } + + for _, query := range queries { + m, ok := query.(map[string]any) + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: item in array is not json object") + } + + text, ok := m["text"] + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: must set `text` in query") + } + + textStr, ok := text.(string) + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: `text` must be string") + } + + t, ok := m["type"] + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: must set `type` in query") + } + + typeStr, ok := t.(string) + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: `type` must be string") + } + + typeEnum, ok := querypb.HighlightQueryType_value[typeStr] + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: invalid highlight query type: %s", typeStr) + } + + f, ok := m["field"] + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: must set `field` in query") + } + fieldStr, ok := f.(string) + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("unmarshal highlight queries failed: `field` must be string") + } + + h.queries = append(h.queries, &highlightQuery{ + text: textStr, + highlightType: querypb.HighlightQueryType(typeEnum), + fieldName: fieldStr, + }) + } + } + return h, nil +} + +type lexicalHighlightOperator struct { + tasks []*highlightTask + fieldSchemas []*schemapb.FieldSchema + lbPolicy shardclient.LBPolicy + scheduler *taskScheduler + + collectionName string + collectionID int64 + dbName string +} + +func newLexicalHighlightOperator(t *searchTask, tasks []*highlightTask) (operator, error) { + return &lexicalHighlightOperator{ + tasks: tasks, + lbPolicy: t.lb, + scheduler: t.node.(*Proxy).sched, + fieldSchemas: typeutil.GetAllFieldSchemas(t.schema.CollectionSchema), + collectionName: t.request.CollectionName, + collectionID: t.CollectionID, + dbName: t.request.DbName, + }, nil +} + +func (op *lexicalHighlightOperator) run(ctx context.Context, span trace.Span, inputs ...any) ([]any, error) { + result := inputs[0].(*milvuspb.SearchResults) + datas := result.Results.GetFieldsData() + req := &querypb.GetHighlightRequest{ + Topks: result.GetResults().GetTopks(), + Tasks: lo.Map(op.tasks, func(task *highlightTask, _ int) *querypb.HighlightTask { return task.HighlightTask }), + } + + for _, task := range req.GetTasks() { + textFieldDatas, ok := lo.Find(datas, func(data *schemapb.FieldData) bool { return data.FieldId == task.GetFieldId() }) + if !ok { + return nil, errors.Errorf("get highlight failed, text field not in output field %s: %d", task.GetFieldName(), task.GetFieldId()) + } + texts := textFieldDatas.GetScalars().GetStringData().GetData() + task.Texts = append(task.Texts, texts...) + task.CorpusTextNum = int64(len(texts)) + field, ok := lo.Find(op.fieldSchemas, func(schema *schemapb.FieldSchema) bool { + return schema.GetFieldID() == task.GetFieldId() + }) + if !ok { + return nil, errors.Errorf("get highlight failed, field not found in schema %s: %d", task.GetFieldName(), task.GetFieldId()) + } + + // if use multi analyzer + // get analyzer field data + helper := typeutil.CreateFieldSchemaHelper(field) + if v, ok := helper.GetMultiAnalyzerParams(); ok { + params := map[string]any{} + err := json.Unmarshal([]byte(v), ¶ms) + if err != nil { + return nil, errors.Errorf("get highlight failed, get invalid multi analyzer params-: %v", err) + } + analyzerField, ok := params["by_field"] + if !ok { + return nil, errors.Errorf("get highlight failed, get invalid multi analyzer params, no by_field") + } + + analyzerFieldDatas, ok := lo.Find(datas, func(data *schemapb.FieldData) bool { return data.FieldName == analyzerField.(string) }) + if !ok { + return nil, errors.Errorf("get highlight failed, analyzer field not in output field") + } + task.AnalyzerNames = append(task.AnalyzerNames, analyzerFieldDatas.GetScalars().GetStringData().GetData()...) + } + } + + task := &HighlightTask{ + ctx: ctx, + lb: op.lbPolicy, + Condition: NewTaskCondition(ctx), + GetHighlightRequest: req, + collectionName: op.collectionName, + collectionID: op.collectionID, + dbName: op.dbName, + } + if err := op.scheduler.dqQueue.Enqueue(task); err != nil { + return nil, err + } + + if err := task.WaitToFinish(); err != nil { + return nil, err + } + + rowNum := len(result.Results.GetScores()) + HighlightResults := []*commonpb.HighlightResult{} + if rowNum != 0 { + rowDatas := lo.Map(task.result.Results, func(result *querypb.HighlightResult, i int) *commonpb.HighlightData { + return buildStringFragments(op.tasks[i/rowNum], i%rowNum, result.GetFragments()) + }) + + for i, task := range req.GetTasks() { + HighlightResults = append(HighlightResults, &commonpb.HighlightResult{ + FieldName: task.GetFieldName(), + Datas: rowDatas[i*rowNum : (i+1)*rowNum], + }) + } + } + + result.Results.HighlightResults = HighlightResults + return []any{result}, nil +} + +func buildStringFragments(task *highlightTask, idx int, frags []*querypb.HighlightFragment) *commonpb.HighlightData { + startOffset := int(task.GetSearchTextNum()) + len(task.Queries) + text := []rune(task.Texts[startOffset+idx]) + preTagsNum := len(task.preTags) + postTagsNum := len(task.postTags) + result := &commonpb.HighlightData{Fragments: make([]string, 0)} + for _, frag := range frags { + var fragString strings.Builder + cursor := int(frag.GetStartOffset()) + for i := 0; i < len(frag.GetOffsets())/2; i++ { + startOffset := int(frag.Offsets[i<<1]) + endOffset := int(frag.Offsets[(i<<1)+1]) + if cursor < startOffset { + fragString.WriteString(string(text[cursor:startOffset])) + } + fragString.WriteString(string(task.preTags[i%preTagsNum])) + fragString.WriteString(string(text[startOffset:endOffset])) + fragString.WriteString(string(task.postTags[i%postTagsNum])) + cursor = endOffset + } + if cursor < int(frag.GetEndOffset()) { + fragString.WriteString(string(text[cursor:frag.GetEndOffset()])) + } + result.Fragments = append(result.Fragments, fragString.String()) + } + return result +} diff --git a/internal/proxy/search_pipeline.go b/internal/proxy/search_pipeline.go index 6ffc03663f..b5b8d2bf16 100644 --- a/internal/proxy/search_pipeline.go +++ b/internal/proxy/search_pipeline.go @@ -112,6 +112,7 @@ const ( organizeOp = "organize" endOp = "end" lambdaOp = "lambda" + highlightOp = "highlight" ) const ( @@ -128,6 +129,7 @@ var opFactory = map[string]func(t *searchTask, params map[string]any) (operator, requeryOp: newRequeryOperator, lambdaOp: newLambdaOperator, endOp: newEndOperator, + highlightOp: newHighlightOperator, } func NewNode(info *nodeDef, t *searchTask) (*Node, error) { @@ -596,6 +598,10 @@ func (op *endOperator) run(ctx context.Context, span trace.Span, inputs ...any) return []any{result}, nil } +func newHighlightOperator(t *searchTask, _ map[string]any) (operator, error) { + return t.highlighter.AsSearchPipelineOperator(t) +} + func mergeIDsFunc(ctx context.Context, span trace.Span, inputs ...any) ([]any, error) { multipleMilvusResults := inputs[0].([]*milvuspb.SearchResults) idInt64Type := false @@ -652,6 +658,17 @@ func newPipeline(pipeDef *pipelineDef, t *searchTask) (*pipeline, error) { return &pipeline{name: pipeDef.name, nodes: nodes}, nil } +func (p *pipeline) AddNodes(t *searchTask, nodes ...*nodeDef) error { + for _, def := range nodes { + node, err := NewNode(def, t) + if err != nil { + return err + } + p.nodes = append(p.nodes, node) + } + return nil +} + func (p *pipeline) Run(ctx context.Context, span trace.Span, toReduceResults []*internalpb.SearchResults, storageCost segcore.StorageCost) (*milvuspb.SearchResults, segcore.StorageCost, error) { log.Ctx(ctx).Debug("SearchPipeline run", zap.String("pipeline", p.String())) msg := opMsg{} @@ -682,6 +699,20 @@ type pipelineDef struct { nodes []*nodeDef } +var filterFieldNode = &nodeDef{ + name: "filter_field", + inputs: []string{"result", "reduced"}, + outputs: []string{"output"}, + opName: endOp, +} + +var highlightNode = &nodeDef{ + name: "highlight", + inputs: []string{"result"}, + outputs: []string{"output"}, + opName: highlightOp, +} + var searchPipe = &pipelineDef{ name: "search", nodes: []*nodeDef{ @@ -703,12 +734,6 @@ var searchPipe = &pipelineDef{ }, opName: lambdaOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -767,12 +792,6 @@ var searchWithRequeryPipe = &pipelineDef{ }, opName: lambdaOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -825,12 +844,6 @@ var searchWithRerankPipe = &pipelineDef{ }, opName: lambdaOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -899,12 +912,6 @@ var searchWithRerankRequeryPipe = &pipelineDef{ }, opName: lambdaOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -923,12 +930,6 @@ var hybridSearchPipe = &pipelineDef{ outputs: []string{"result"}, opName: rerankOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -1030,12 +1031,6 @@ var hybridSearchWithRequeryAndRerankByFieldDataPipe = &pipelineDef{ }, opName: lambdaOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -1093,12 +1088,6 @@ var hybridSearchWithRequeryPipe = &pipelineDef{ }, opName: lambdaOp, }, - { - name: "filter_field", - inputs: []string{"result", "reduced"}, - outputs: []string{pipelineOutput}, - opName: endOp, - }, }, } @@ -1142,3 +1131,23 @@ func aggregatedAllSearchCount(searchResults []*milvuspb.SearchResults) int64 { } return allSearchCount } + +func newSearchPipeline(t *searchTask) (*pipeline, error) { + p, err := newBuiltInPipeline(t) + if err != nil { + return nil, err + } + + if t.highlighter != nil { + err := p.AddNodes(t, highlightNode, filterFieldNode) + if err != nil { + return nil, err + } + } else { + err := p.AddNodes(t, filterFieldNode) + if err != nil { + return nil, err + } + } + return p, nil +} diff --git a/internal/proxy/search_pipeline_test.go b/internal/proxy/search_pipeline_test.go index e6e587f3ba..d4e0f42d77 100644 --- a/internal/proxy/search_pipeline_test.go +++ b/internal/proxy/search_pipeline_test.go @@ -24,6 +24,7 @@ import ( "time" "github.com/bytedance/mockey" + "github.com/stretchr/testify/mock" "github.com/stretchr/testify/suite" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/trace" @@ -31,10 +32,14 @@ import ( "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" + "github.com/milvus-io/milvus/internal/mocks" + "github.com/milvus-io/milvus/internal/proxy/shardclient" "github.com/milvus-io/milvus/internal/util/function/rerank" "github.com/milvus-io/milvus/internal/util/segcore" "github.com/milvus-io/milvus/pkg/v2/proto/internalpb" "github.com/milvus-io/milvus/pkg/v2/proto/planpb" + "github.com/milvus-io/milvus/pkg/v2/proto/querypb" + "github.com/milvus-io/milvus/pkg/v2/util/merr" "github.com/milvus-io/milvus/pkg/v2/util/testutils" "github.com/milvus-io/milvus/pkg/v2/util/timerecord" ) @@ -266,6 +271,96 @@ func (s *SearchPipelineSuite) TestOrganizeOp() { fmt.Println(ret) } +func (s *SearchPipelineSuite) TestHighlightOp() { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + proxy := &Proxy{} + proxy.tsoAllocator = ×tampAllocator{ + tso: newMockTimestampAllocatorInterface(), + } + sched, err := newTaskScheduler(ctx, proxy.tsoAllocator) + s.Require().NoError(err) + + err = sched.Start() + s.Require().NoError(err) + defer sched.Close() + proxy.sched = sched + + collName := "test_coll_highlight" + fieldName2Types := map[string]schemapb.DataType{ + testVarCharField: schemapb.DataType_VarChar, + } + schema := constructCollectionSchemaByDataType(collName, fieldName2Types, testVarCharField, false) + + req := &milvuspb.SearchRequest{ + CollectionName: collName, + DbName: "default", + } + + highlightTasks := map[int64]*highlightTask{ + 100: { + HighlightTask: &querypb.HighlightTask{ + Texts: []string{"target text"}, + FieldName: testVarCharField, + FieldId: 100, + }, + preTags: [][]byte{[]byte(DefaultPreTag)}, + postTags: [][]byte{[]byte(DefaultPostTag)}, + }, + } + + mockLb := shardclient.NewMockLBPolicy(s.T()) + searchTask := &searchTask{ + node: proxy, + highlighter: &LexicalHighlighter{ + tasks: highlightTasks, + }, + lb: mockLb, + schema: newSchemaInfo(schema), + request: req, + collectionName: collName, + SearchRequest: &internalpb.SearchRequest{ + CollectionID: 0, + }, + } + + op, err := opFactory[highlightOp](searchTask, map[string]any{}) + s.Require().NoError(err) + + // mockery + mockLb.EXPECT().ExecuteOneChannel(mock.Anything, mock.Anything).Run(func(ctx context.Context, workload shardclient.CollectionWorkLoad) { + qn := mocks.NewMockQueryNodeClient(s.T()) + qn.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return( + &querypb.GetHighlightResponse{ + Status: merr.Success(), + Results: []*querypb.HighlightResult{}, + }, nil) + workload.Exec(ctx, 0, qn, "test_chan") + }).Return(nil) + + _, err = op.run(ctx, s.span, &milvuspb.SearchResults{ + Results: &schemapb.SearchResultData{ + TopK: 3, + Topks: []int64{1}, + FieldsData: []*schemapb.FieldData{{ + FieldName: testVarCharField, + FieldId: 100, + Field: &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_StringData{ + StringData: &schemapb.StringArray{ + Data: []string{"match text"}, + }, + }, + }, + }, + }}, + }, + }) + s.NoError(err) +} + func (s *SearchPipelineSuite) TestSearchPipeline() { collectionName := "test" task := &searchTask{ @@ -295,8 +390,11 @@ func (s *SearchPipelineSuite) TestSearchPipeline() { queryInfos: []*planpb.QueryInfo{{}}, translatedOutputFields: []string{"intField"}, } + pipeline, err := newPipeline(searchPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) + sr := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, false) results, storageCost, err := pipeline.Run(context.Background(), s.span, []*internalpb.SearchResults{sr}, segcore.StorageCost{ScannedRemoteBytes: 100, ScannedTotalBytes: 250}) s.NoError(err) @@ -363,6 +461,8 @@ func (s *SearchPipelineSuite) TestSearchPipelineWithRequery() { pipeline, err := newPipeline(searchWithRequeryPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) + results, storageCost, err := pipeline.Run(context.Background(), s.span, []*internalpb.SearchResults{ genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, false), }, segcore.StorageCost{ScannedRemoteBytes: 100, ScannedTotalBytes: 200}) @@ -435,6 +535,7 @@ func (s *SearchPipelineSuite) TestSearchWithRerankPipe() { pipeline, err := newPipeline(searchWithRerankPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) searchResults := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, false) results, _, err := pipeline.Run(context.Background(), s.span, []*internalpb.SearchResults{searchResults}, segcore.StorageCost{}) @@ -518,6 +619,7 @@ func (s *SearchPipelineSuite) TestSearchWithRerankRequeryPipe() { pipeline, err := newPipeline(searchWithRerankRequeryPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) searchResults := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, false) results, storageCost, err := pipeline.Run(context.Background(), s.span, []*internalpb.SearchResults{searchResults}, segcore.StorageCost{}) @@ -552,6 +654,7 @@ func (s *SearchPipelineSuite) TestHybridSearchPipe() { pipeline, err := newPipeline(hybridSearchPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) f1 := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, true) f2 := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, true) @@ -665,6 +768,7 @@ func (s *SearchPipelineSuite) TestHybridSearchWithRequeryAndRerankByDataPipe() { pipeline, err := newPipeline(hybridSearchWithRequeryAndRerankByFieldDataPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) d1 := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, true) d2 := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, true) @@ -707,6 +811,7 @@ func (s *SearchPipelineSuite) TestHybridSearchWithRequeryPipe() { pipeline, err := newPipeline(hybridSearchWithRequeryPipe, task) s.NoError(err) + pipeline.AddNodes(task, filterFieldNode) d1 := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, true) d2 := genTestSearchResultData(2, 10, schemapb.DataType_Int64, "intField", 101, true) diff --git a/internal/proxy/task.go b/internal/proxy/task.go index 8c3ce4b30d..1930daa6c4 100644 --- a/internal/proxy/task.go +++ b/internal/proxy/task.go @@ -65,6 +65,7 @@ const ( StrictCastKey = "strict_cast" RankGroupScorer = "rank_group_scorer" AnnsFieldKey = "anns_field" + AnalyzerKey = "analyzer_name" TopKKey = "topk" NQKey = "nq" MetricTypeKey = common.MetricTypeKey @@ -114,6 +115,7 @@ const ( ListResourceGroupsTaskName = "ListResourceGroupsTask" DescribeResourceGroupTaskName = "DescribeResourceGroupTask" RunAnalyzerTaskName = "RunAnalyzer" + HighlightTaskName = "Highlight" CreateDatabaseTaskName = "CreateCollectionTask" DropDatabaseTaskName = "DropDatabaseTaskName" @@ -3144,6 +3146,95 @@ func (t *RunAnalyzerTask) PostExecute(ctx context.Context) error { return nil } +// git highlight after search +type HighlightTask struct { + baseTask + Condition + *querypb.GetHighlightRequest + ctx context.Context + collectionName string + collectionID typeutil.UniqueID + dbName string + lb shardclient.LBPolicy + + result *querypb.GetHighlightResponse +} + +func (t *HighlightTask) TraceCtx() context.Context { + return t.ctx +} + +func (t *HighlightTask) ID() UniqueID { + return t.Base.MsgID +} + +func (t *HighlightTask) SetID(uid UniqueID) { + t.Base.MsgID = uid +} + +func (t *HighlightTask) Name() string { + return HighlightTaskName +} + +func (t *HighlightTask) Type() commonpb.MsgType { + return t.Base.MsgType +} + +func (t *HighlightTask) BeginTs() Timestamp { + return t.Base.Timestamp +} + +func (t *HighlightTask) EndTs() Timestamp { + return t.Base.Timestamp +} + +func (t *HighlightTask) SetTs(ts Timestamp) { + t.Base.Timestamp = ts +} + +func (t *HighlightTask) OnEnqueue() error { + if t.Base == nil { + t.Base = commonpbutil.NewMsgBase() + } + t.Base.MsgType = commonpb.MsgType_Undefined + t.Base.SourceID = paramtable.GetNodeID() + return nil +} + +func (t *HighlightTask) PreExecute(ctx context.Context) error { + return nil +} + +func (t *HighlightTask) getHighlightOnShardleader(ctx context.Context, nodeID int64, qn types.QueryNodeClient, channel string) error { + t.GetHighlightRequest.Channel = channel + resp, err := qn.GetHighlight(ctx, t.GetHighlightRequest) + if err != nil { + return err + } + + if err := merr.Error(resp.GetStatus()); err != nil { + return err + } + t.result = resp + return nil +} + +func (t *HighlightTask) Execute(ctx context.Context) error { + err := t.lb.ExecuteOneChannel(ctx, shardclient.CollectionWorkLoad{ + Db: t.dbName, + CollectionName: t.collectionName, + CollectionID: t.collectionID, + Nq: int64(len(t.GetTopks()) * len(t.GetTasks())), + Exec: t.getHighlightOnShardleader, + }) + + return err +} + +func (t *HighlightTask) PostExecute(ctx context.Context) error { + return nil +} + // isIgnoreGrowing is used to check if the request should ignore growing func isIgnoreGrowing(params []*commonpb.KeyValuePair) (bool, error) { for _, kv := range params { diff --git a/internal/proxy/task_search.go b/internal/proxy/task_search.go index 28fb288c46..ce95d7afe2 100644 --- a/internal/proxy/task_search.go +++ b/internal/proxy/task_search.go @@ -80,8 +80,8 @@ type searchTask struct { translatedOutputFields []string userOutputFields []string userDynamicFields []string - - resultBuf *typeutil.ConcurrentSet[*internalpb.SearchResults] + highlighter Highlighter + resultBuf *typeutil.ConcurrentSet[*internalpb.SearchResults] partitionIDsSet *typeutil.ConcurrentSet[UniqueID] @@ -466,12 +466,13 @@ func (t *searchTask) initAdvancedSearchRequest(ctx context.Context) error { } // set analyzer name for sub search - analyzer, err := funcutil.GetAttrByKeyFromRepeatedKV("analyzer_name", subReq.GetSearchParams()) + analyzer, err := funcutil.GetAttrByKeyFromRepeatedKV(AnalyzerKey, subReq.GetSearchParams()) if err == nil { internalSubReq.AnalyzerName = analyzer } internalSubReq.FieldId = queryInfo.GetQueryFieldId() + queryFieldIDs = append(queryFieldIDs, internalSubReq.FieldId) // set PartitionIDs for sub search if t.partitionKeyMode { @@ -557,6 +558,67 @@ func (t *searchTask) fillResult() { t.result.CollectionName = t.collectionName } +func (t *searchTask) getBM25SearchTexts(placeholder []byte) ([]string, error) { + pb := &commonpb.PlaceholderGroup{} + proto.Unmarshal(placeholder, pb) + + if len(pb.Placeholders) != 1 || len(pb.Placeholders[0].Values) == 0 { + return nil, merr.WrapErrParameterInvalidMsg("please provide varchar/text for BM25 Function based search") + } + + holder := pb.Placeholders[0] + if holder.Type != commonpb.PlaceholderType_VarChar { + return nil, merr.WrapErrParameterInvalidMsg(fmt.Sprintf("please provide varchar/text for BM25 Function based search, got %s", holder.Type.String())) + } + + texts := funcutil.GetVarCharFromPlaceholder(holder) + return texts, nil +} + +func (t *searchTask) createLexicalHighlighter(highlighter *commonpb.Highlighter, metricType string, annsField int64, placeholder []byte, analyzerName string) error { + h, err := NewLexicalHighlighter(highlighter) + if err != nil { + return err + } + t.highlighter = h + if h.highlightSearch { + if metricType != metric.BM25 { + return merr.WrapErrParameterInvalidMsg(`Search highlight only support with metric type "BM25" but was: %s`, t.SearchRequest.GetMetricType()) + } + function, ok := getBM25FunctionOfAnnsField(annsField, t.schema.GetFunctions()) + if !ok { + return merr.WrapErrServiceInternal(`Search with highlight failed, input field of BM25 annsField not found`) + } + fieldId := function.InputFieldIds[0] + fieldName := function.InputFieldNames[0] + // set bm25 search text as highlight search texts + texts, err := t.getBM25SearchTexts(placeholder) + if err != nil { + return err + } + err = h.addTaskWithSearchText(fieldId, fieldName, analyzerName, texts) + if err != nil { + return err + } + + return h.initHighlightQueries(t) + } + return nil +} + +func (t *searchTask) addHighlightTask(highlighter *commonpb.Highlighter, metricType string, annsField int64, placeholder []byte, analyzerName string) error { + if highlighter == nil { + return nil + } + + switch highlighter.GetType() { + case commonpb.HighlightType_Lexical: + return t.createLexicalHighlighter(highlighter, metricType, annsField, placeholder, analyzerName) + default: + return merr.WrapErrParameterInvalidMsg("unsupported highlight type: %v", highlighter.GetType()) + } +} + func (t *searchTask) initSearchRequest(ctx context.Context) error { ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "init search request") defer sp.End() @@ -579,10 +641,24 @@ func (t *searchTask) initSearchRequest(ctx context.Context) error { } } + analyzer, err := funcutil.GetAttrByKeyFromRepeatedKV(AnalyzerKey, t.request.GetSearchParams()) + if err == nil { + t.SearchRequest.AnalyzerName = analyzer + } + t.isIterator = isIterator t.SearchRequest.Offset = offset t.SearchRequest.FieldId = queryInfo.GetQueryFieldId() + if err := t.addHighlightTask(t.request.GetHighlighter(), queryInfo.GetMetricType(), queryInfo.GetQueryFieldId(), t.request.GetPlaceholderGroup(), t.SearchRequest.GetAnalyzerName()); err != nil { + return err + } + + // add highlight field ids to output fields id + if t.highlighter != nil { + t.SearchRequest.OutputFieldsId = append(t.SearchRequest.OutputFieldsId, t.highlighter.FieldIDs()...) + } + if t.partitionKeyMode { // isolation has tighter constraint, check first mvErr := setQueryInfoIfMvEnable(queryInfo, t, plan) @@ -632,13 +708,6 @@ func (t *searchTask) initSearchRequest(ctx context.Context) error { t.SearchRequest.GroupByFieldId = queryInfo.GroupByFieldId t.SearchRequest.GroupSize = queryInfo.GroupSize - if t.SearchRequest.MetricType == metric.BM25 { - analyzer, err := funcutil.GetAttrByKeyFromRepeatedKV("analyzer_name", t.request.GetSearchParams()) - if err == nil { - t.SearchRequest.AnalyzerName = analyzer - } - } - if embedding.HasNonBM25Functions(t.schema.CollectionSchema.Functions, []int64{queryInfo.GetQueryFieldId()}) { ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-Search-call-function-udf") defer sp.End() @@ -813,7 +882,7 @@ func (t *searchTask) PostExecute(ctx context.Context) error { t.isRecallEvaluation = isRecallEvaluation // call pipeline - pipeline, err := newBuiltInPipeline(t) + pipeline, err := newSearchPipeline(t) if err != nil { log.Warn("Faild to create post process pipeline") return err diff --git a/internal/proxy/task_search_test.go b/internal/proxy/task_search_test.go index 6d6ba28eb7..9f6579baa0 100644 --- a/internal/proxy/task_search_test.go +++ b/internal/proxy/task_search_test.go @@ -4885,3 +4885,198 @@ func TestSearchTask_InitSearchRequestWithStructArrayFields(t *testing.T) { }) } } + +func TestSearchTask_AddHighlightTask(t *testing.T) { + paramtable.Init() + + // Create a schema with BM25 function + schema := &schemapb.CollectionSchema{ + Name: "test_highlight_collection", + Fields: []*schemapb.FieldSchema{ + { + FieldID: 100, + Name: "text_field", + DataType: schemapb.DataType_VarChar, + }, + { + FieldID: 101, + Name: "sparse_field", + DataType: schemapb.DataType_SparseFloatVector, + }, + }, + Functions: []*schemapb.FunctionSchema{ + { + Name: "bm25_func", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + InputFieldIds: []int64{100}, + OutputFieldNames: []string{"sparse_field"}, + OutputFieldIds: []int64{101}, + }, + }, + } + + placeholder := &commonpb.PlaceholderGroup{ + Placeholders: []*commonpb.PlaceholderValue{{ + Type: commonpb.PlaceholderType_VarChar, + Values: [][]byte{[]byte("test_str")}, + }}, + } + + placeholderBytes, err := proto.Marshal(placeholder) + require.NoError(t, err) + + t.Run("lexical highlight success", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "true"}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 101, placeholderBytes, "") + assert.NoError(t, err) + + h, ok := task.highlighter.(*LexicalHighlighter) + require.True(t, ok) + require.Equal(t, 1, len(h.tasks)) + assert.Equal(t, int64(100), h.tasks[100].FieldId) + assert.Equal(t, "text_field", h.tasks[100].FieldName) + }) + + t.Run("Lexical highlight with custom tags", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "true"}, {Key: "pre_tags", Value: `[""]`}, {Key: "post_tags", Value: `[""]`}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 101, placeholderBytes, "") + assert.NoError(t, err) + + h, ok := task.highlighter.(*LexicalHighlighter) + require.True(t, ok) + assert.Equal(t, 1, len(h.preTags)) + assert.Equal(t, []byte(""), h.preTags[0]) + assert.Equal(t, 1, len(h.postTags)) + assert.Equal(t, []byte(""), h.postTags[0]) + }) + + t.Run("lexical highlight with wrong metric type", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + SearchRequest: &internalpb.SearchRequest{}, + request: &milvuspb.SearchRequest{}, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "true"}}, + } + + err := task.addHighlightTask(highlighter, metric.L2, 101, placeholderBytes, "") + assert.Error(t, err) + }) + + t.Run("lexical highlight with invalid pre_tags type", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "true"}, {Key: "pre_tags", Value: "not_a_list"}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 101, placeholderBytes, "") + assert.Error(t, err) + }) + + t.Run("default lexical highlight but not BM25 field", func(t *testing.T) { + schemaWithoutBM25 := &schemapb.CollectionSchema{ + Name: "test_collection", + Fields: []*schemapb.FieldSchema{ + { + FieldID: 100, + Name: "vector_field", + DataType: schemapb.DataType_FloatVector, + }, + }, + } + + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schemaWithoutBM25, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "true"}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 100, placeholderBytes, "") + assert.Error(t, err) + }) + + t.Run("highlight without highlight search text", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "false"}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 101, placeholderBytes, "") + assert.NoError(t, err) + }) + + t.Run("highlight with invalid highlight search key", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: commonpb.HighlightType_Lexical, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "invalid"}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 101, placeholderBytes, "") + assert.Error(t, err) + }) + + t.Run("highlight with unknown type", func(t *testing.T) { + task := &searchTask{ + schema: &schemaInfo{ + CollectionSchema: schema, + }, + } + + highlighter := &commonpb.Highlighter{ + Type: 4, + Params: []*commonpb.KeyValuePair{{Key: HighlightSearchTextKey, Value: "true"}}, + } + + err := task.addHighlightTask(highlighter, metric.BM25, 101, placeholderBytes, "") + assert.Error(t, err) + }) +} diff --git a/internal/proxy/task_test.go b/internal/proxy/task_test.go index d59332331c..fbf0a499d7 100644 --- a/internal/proxy/task_test.go +++ b/internal/proxy/task_test.go @@ -39,6 +39,7 @@ import ( "github.com/milvus-io/milvus/internal/allocator" "github.com/milvus-io/milvus/internal/json" "github.com/milvus-io/milvus/internal/mocks" + "github.com/milvus-io/milvus/internal/proxy/shardclient" "github.com/milvus-io/milvus/internal/querycoordv2/meta" "github.com/milvus-io/milvus/internal/util/function/embedding" "github.com/milvus-io/milvus/pkg/v2/common" @@ -5497,3 +5498,237 @@ func TestAlterCollection_AllowInsertAutoID_AutoIDFalse(t *testing.T) { assert.Error(t, err) assert.Equal(t, merr.Code(merr.ErrParameterInvalid), merr.Code(err)) } + +func TestHighlightTask(t *testing.T) { + paramtable.Init() + ctx := context.Background() + + t.Run("basic methods", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + }, + Condition: NewTaskCondition(ctx), + } + + t.Run("traceCtx", func(t *testing.T) { + traceCtx := task.TraceCtx() + assert.NotNil(t, traceCtx) + assert.Equal(t, ctx, traceCtx) + }) + + t.Run("id", func(t *testing.T) { + id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt()) + task.SetID(id) + assert.Equal(t, id, task.ID()) + }) + + t.Run("name", func(t *testing.T) { + assert.Equal(t, HighlightTaskName, task.Name()) + }) + + t.Run("type", func(t *testing.T) { + assert.Equal(t, commonpb.MsgType_Undefined, task.Type()) + }) + + t.Run("ts", func(t *testing.T) { + ts := Timestamp(time.Now().UnixNano()) + task.SetTs(ts) + assert.Equal(t, ts, task.BeginTs()) + assert.Equal(t, ts, task.EndTs()) + }) + }) + + t.Run("OnEnqueue", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{}, + Condition: NewTaskCondition(ctx), + } + + err := task.OnEnqueue() + assert.NoError(t, err) + assert.NotNil(t, task.Base) + assert.Equal(t, commonpb.MsgType_Undefined, task.Base.MsgType) + assert.Equal(t, paramtable.GetNodeID(), task.Base.SourceID) + }) + + t.Run("PreExecute", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + }, + Condition: NewTaskCondition(ctx), + } + + err := task.PreExecute(ctx) + assert.NoError(t, err) + }) + + t.Run("getHighlightOnShardleader success", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + Topks: []int64{10}, + Tasks: []*querypb.HighlightTask{ + {}, + }, + }, + Condition: NewTaskCondition(ctx), + } + + mockQN := mocks.NewMockQueryNodeClient(t) + expectedResp := &querypb.GetHighlightResponse{ + Status: merr.Success(), + Results: []*querypb.HighlightResult{ + { + Fragments: []*querypb.HighlightFragment{ + { + StartOffset: 0, + EndOffset: 10, + Offsets: []int64{0, 5, 5, 10}, + }, + }, + }, + }, + } + + mockQN.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return(expectedResp, nil) + + err := task.getHighlightOnShardleader(ctx, 1, mockQN, "test_channel") + assert.NoError(t, err) + assert.NotNil(t, task.result) + assert.Equal(t, expectedResp, task.result) + assert.Equal(t, "test_channel", task.GetHighlightRequest.Channel) + }) + + t.Run("getHighlightOnShardleader rpc error", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + }, + Condition: NewTaskCondition(ctx), + } + + mockQN := mocks.NewMockQueryNodeClient(t) + mockQN.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return(nil, errors.New("rpc error")) + + err := task.getHighlightOnShardleader(ctx, 1, mockQN, "test_channel") + assert.Error(t, err) + assert.Contains(t, err.Error(), "rpc error") + }) + + t.Run("getHighlightOnShardleader status error", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + }, + Condition: NewTaskCondition(ctx), + } + + mockQN := mocks.NewMockQueryNodeClient(t) + expectedResp := &querypb.GetHighlightResponse{ + Status: merr.Status(errors.New("status error")), + } + + mockQN.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return(expectedResp, nil) + + err := task.getHighlightOnShardleader(ctx, 1, mockQN, "test_channel") + assert.Error(t, err) + }) + + t.Run("Execute success", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + collectionName: "test_collection", + collectionID: 100, + dbName: "default", + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + Topks: []int64{10, 20}, + Tasks: []*querypb.HighlightTask{ + {}, + {}, + }, + }, + Condition: NewTaskCondition(ctx), + } + + mockLB := shardclient.NewMockLBPolicy(t) + mockQN := mocks.NewMockQueryNodeClient(t) + + expectedResp := &querypb.GetHighlightResponse{ + Status: merr.Success(), + Results: []*querypb.HighlightResult{ + { + Fragments: []*querypb.HighlightFragment{ + { + StartOffset: 0, + EndOffset: 10, + Offsets: []int64{0, 5, 5, 10}, + }, + }, + }, + }, + } + + mockQN.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return(expectedResp, nil) + + mockLB.EXPECT().ExecuteOneChannel(mock.Anything, mock.Anything).Run( + func(ctx context.Context, workload shardclient.CollectionWorkLoad) { + assert.Equal(t, "default", workload.Db) + assert.Equal(t, "test_collection", workload.CollectionName) + assert.Equal(t, int64(100), workload.CollectionID) + assert.Equal(t, int64(4), workload.Nq) // len(topks) * len(tasks) = 2 * 2 = 4 + err := workload.Exec(ctx, 1, mockQN, "test_channel") + assert.NoError(t, err) + }, + ).Return(nil) + + task.lb = mockLB + + err := task.Execute(ctx) + assert.NoError(t, err) + assert.NotNil(t, task.result) + }) + + t.Run("Execute lb error", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + collectionName: "test_collection", + collectionID: 100, + dbName: "default", + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + }, + Condition: NewTaskCondition(ctx), + } + + mockLB := shardclient.NewMockLBPolicy(t) + mockLB.EXPECT().ExecuteOneChannel(mock.Anything, mock.Anything).Return(errors.New("lb error")) + + task.lb = mockLB + + err := task.Execute(ctx) + assert.Error(t, err) + assert.Contains(t, err.Error(), "lb error") + }) + + t.Run("PostExecute", func(t *testing.T) { + task := &HighlightTask{ + ctx: ctx, + GetHighlightRequest: &querypb.GetHighlightRequest{ + Base: commonpbutil.NewMsgBase(), + }, + Condition: NewTaskCondition(ctx), + } + + err := task.PostExecute(ctx) + assert.NoError(t, err) + }) +} diff --git a/internal/proxy/util.go b/internal/proxy/util.go index 3d5b869194..a84848155b 100644 --- a/internal/proxy/util.go +++ b/internal/proxy/util.go @@ -3040,3 +3040,9 @@ func genFunctionFields(ctx context.Context, insertMsg *msgstream.InsertMsg, sche } return nil } + +func getBM25FunctionOfAnnsField(fieldID int64, functions []*schemapb.FunctionSchema) (*schemapb.FunctionSchema, bool) { + return lo.Find(functions, func(function *schemapb.FunctionSchema) bool { + return function.GetType() == schemapb.FunctionType_BM25 && function.OutputFieldIds[0] == fieldID + }) +} diff --git a/internal/querycoordv2/mocks/mock_querynode.go b/internal/querycoordv2/mocks/mock_querynode.go index c0de5bc446..cea5c00b65 100644 --- a/internal/querycoordv2/mocks/mock_querynode.go +++ b/internal/querycoordv2/mocks/mock_querynode.go @@ -324,6 +324,65 @@ func (_c *MockQueryNodeServer_GetDataDistribution_Call) RunAndReturn(run func(co return _c } +// GetHighlight provides a mock function with given fields: _a0, _a1 +func (_m *MockQueryNodeServer) GetHighlight(_a0 context.Context, _a1 *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetHighlight") + } + + var r0 *querypb.GetHighlightResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest) *querypb.GetHighlightResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*querypb.GetHighlightResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetHighlightRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNodeServer_GetHighlight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHighlight' +type MockQueryNodeServer_GetHighlight_Call struct { + *mock.Call +} + +// GetHighlight is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *querypb.GetHighlightRequest +func (_e *MockQueryNodeServer_Expecter) GetHighlight(_a0 interface{}, _a1 interface{}) *MockQueryNodeServer_GetHighlight_Call { + return &MockQueryNodeServer_GetHighlight_Call{Call: _e.mock.On("GetHighlight", _a0, _a1)} +} + +func (_c *MockQueryNodeServer_GetHighlight_Call) Run(run func(_a0 context.Context, _a1 *querypb.GetHighlightRequest)) *MockQueryNodeServer_GetHighlight_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.GetHighlightRequest)) + }) + return _c +} + +func (_c *MockQueryNodeServer_GetHighlight_Call) Return(_a0 *querypb.GetHighlightResponse, _a1 error) *MockQueryNodeServer_GetHighlight_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNodeServer_GetHighlight_Call) RunAndReturn(run func(context.Context, *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error)) *MockQueryNodeServer_GetHighlight_Call { + _c.Call.Return(run) + return _c +} + // GetMetrics provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetMetrics(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { ret := _m.Called(_a0, _a1) diff --git a/internal/querynodev2/delegator/delegator.go b/internal/querynodev2/delegator/delegator.go index 6f379a3a10..5e68107cc7 100644 --- a/internal/querynodev2/delegator/delegator.go +++ b/internal/querynodev2/delegator/delegator.go @@ -104,6 +104,7 @@ type ShardDelegator interface { // analyzer RunAnalyzer(ctx context.Context, req *querypb.RunAnalyzerRequest) ([]*milvuspb.AnalyzerResult, error) + GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error) // control Serviceable() bool diff --git a/internal/querynodev2/delegator/delegator_data.go b/internal/querynodev2/delegator/delegator_data.go index 9bc846e4a3..ab35368576 100644 --- a/internal/querynodev2/delegator/delegator_data.go +++ b/internal/querynodev2/delegator/delegator_data.go @@ -29,6 +29,7 @@ import ( "google.golang.org/protobuf/proto" "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" "github.com/milvus-io/milvus-proto/go-api/v2/msgpb" "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" "github.com/milvus-io/milvus/internal/querynodev2/cluster" @@ -1001,3 +1002,87 @@ func (sd *shardDelegator) DropIndex(ctx context.Context, req *querypb.DropIndexR } return nil } + +func (sd *shardDelegator) GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error) { + result := []*querypb.HighlightResult{} + for _, task := range req.GetTasks() { + if len(task.GetTexts()) != int(task.GetSearchTextNum()+task.GetCorpusTextNum())+len(task.GetQueries()) { + return nil, errors.Errorf("package highlight texts error, num of texts not equal the expected num %d:%d", len(task.GetTexts()), int(task.GetSearchTextNum()+task.GetCorpusTextNum())+len(task.GetQueries())) + } + analyzer, ok := sd.analyzerRunners[task.GetFieldId()] + if !ok { + return nil, merr.WrapErrParameterInvalidMsg("get highlight failed, the highlight field not found, %s:%d", task.GetFieldName(), task.GetFieldId()) + } + topks := req.GetTopks() + var results [][]*milvuspb.AnalyzerToken + var err error + + if len(analyzer.GetInputFields()) == 1 { + results, err = analyzer.BatchAnalyze(true, false, task.GetTexts()) + if err != nil { + return nil, err + } + } else if len(analyzer.GetInputFields()) == 2 { + // use analyzer names if analyzer need two input field + results, err = analyzer.BatchAnalyze(true, false, task.GetTexts(), task.GetAnalyzerNames()) + if err != nil { + return nil, err + } + } + + // analyze result of search text + searchResults := results[0:task.SearchTextNum] + // analyze result of query text + queryResults := results[task.SearchTextNum : task.SearchTextNum+int64(len(task.Queries))] + // analyze result of corpus text + corpusStartOffset := int(task.SearchTextNum) + len(task.Queries) + corpusResults := results[corpusStartOffset:] + + // query for all corpus texts + // only support text match now + // build match set for all analyze result of query text + // TODO: support more query types + queryTokenSet := typeutil.NewSet[string]() + for _, tokens := range queryResults { + for _, token := range tokens { + queryTokenSet.Insert(token.GetToken()) + } + } + + corpusIdx := 0 + for i := range len(topks) { + tokenSet := typeutil.NewSet[string]() + if len(searchResults) > i { + for _, token := range searchResults[i] { + tokenSet.Insert(token.GetToken()) + } + } + + for j := 0; j < int(topks[i]); j++ { + spans := SpanList{} + for _, token := range corpusResults[corpusIdx] { + if tokenSet.Contain(token.GetToken()) || queryTokenSet.Contain(token.GetToken()) { + spans = append(spans, Span{token.GetStartOffset(), token.GetEndOffset()}) + } + } + spans = mergeOffsets(spans) + + // Convert byte offsets from analyzer to rune (character) offsets + corpusText := task.Texts[corpusStartOffset+corpusIdx] + err := bytesOffsetToRuneOffset(corpusText, spans) + if err != nil { + return nil, err + } + + frags := fetchFragmentsFromOffsets(corpusText, spans, + task.GetOptions().GetFragmentOffset(), + task.GetOptions().GetFragmentSize(), + task.GetOptions().GetNumOfFragments()) + result = append(result, &querypb.HighlightResult{Fragments: frags}) + corpusIdx++ + } + } + } + + return result, nil +} diff --git a/internal/querynodev2/delegator/delegator_test.go b/internal/querynodev2/delegator/delegator_test.go index 6543dd2b75..124724d0fc 100644 --- a/internal/querynodev2/delegator/delegator_test.go +++ b/internal/querynodev2/delegator/delegator_test.go @@ -1596,6 +1596,159 @@ func (s *DelegatorSuite) TestRunAnalyzer() { }) } +func (s *DelegatorSuite) TestGetHighlight() { + ctx := context.Background() + s.TestCreateDelegatorWithFunction() + + s.Run("field analyzer not exist", func() { + _, err := s.delegator.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Topks: []int64{1}, + Tasks: []*querypb.HighlightTask{ + { + FieldId: 999, // non-existent field + }, + }, + }) + s.Require().Error(err) + }) + + s.Run("normal highlight with single analyzer", func() { + s.manager.Collection.PutOrRef(s.collectionID, &schemapb.CollectionSchema{ + Fields: []*schemapb.FieldSchema{ + { + FieldID: 100, + Name: "text", + DataType: schemapb.DataType_VarChar, + TypeParams: []*commonpb.KeyValuePair{{Key: "analyzer_params", Value: "{}"}}, + }, + { + FieldID: 101, + Name: "sparse", + DataType: schemapb.DataType_SparseFloatVector, + }, + }, + Functions: []*schemapb.FunctionSchema{{ + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text"}, + InputFieldIds: []int64{100}, + OutputFieldNames: []string{"sparse"}, + OutputFieldIds: []int64{101}, + }}, + }, nil, &querypb.LoadMetaInfo{SchemaVersion: tsoutil.ComposeTSByTime(time.Now(), 0)}) + s.ResetDelegator() + + result, err := s.delegator.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Topks: []int64{2}, + Tasks: []*querypb.HighlightTask{ + { + FieldId: 100, + Texts: []string{"test", "this is a test document", "another test case"}, + SearchTextNum: 1, + CorpusTextNum: 2, + }, + }, + }) + s.Require().NoError(err) + s.Require().Equal(2, len(result)) + // Check that we got highlight results + s.Require().NotNil(result[0].Fragments) + s.Require().NotNil(result[1].Fragments) + }) + + s.Run("highlight with multi analyzer", func() { + s.manager.Collection.PutOrRef(s.collectionID, &schemapb.CollectionSchema{ + Fields: []*schemapb.FieldSchema{ + { + FieldID: 100, + Name: "text", + DataType: schemapb.DataType_VarChar, + TypeParams: []*commonpb.KeyValuePair{{Key: "multi_analyzer_params", Value: `{ + "by_field": "analyzer", + "analyzers": { + "standard": {}, + "default": {} + } + }`}}, + }, + { + FieldID: 101, + Name: "sparse", + DataType: schemapb.DataType_SparseFloatVector, + }, + { + FieldID: 102, + Name: "analyzer", + DataType: schemapb.DataType_VarChar, + }, + }, + Functions: []*schemapb.FunctionSchema{{ + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text"}, + InputFieldIds: []int64{100}, + OutputFieldNames: []string{"sparse"}, + OutputFieldIds: []int64{101}, + }}, + }, nil, &querypb.LoadMetaInfo{SchemaVersion: tsoutil.ComposeTSByTime(time.Now(), 0)}) + s.ResetDelegator() + + // two target with two analyzer + result, err := s.delegator.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Topks: []int64{1, 1}, + Tasks: []*querypb.HighlightTask{ + { + FieldId: 100, + Texts: []string{"test1", "test2", "this is a test1 document", "another test2 case"}, + AnalyzerNames: []string{"default", "standard", "default", "default"}, + SearchTextNum: 2, + CorpusTextNum: 2, + }, + }, + }) + s.Require().NoError(err) + s.Require().Equal(2, len(result)) + }) + + s.Run("empty target texts", func() { + s.manager.Collection.PutOrRef(s.collectionID, &schemapb.CollectionSchema{ + Fields: []*schemapb.FieldSchema{ + { + FieldID: 100, + Name: "text", + DataType: schemapb.DataType_VarChar, + TypeParams: []*commonpb.KeyValuePair{{Key: "analyzer_params", Value: "{}"}}, + }, + { + FieldID: 101, + Name: "sparse", + DataType: schemapb.DataType_SparseFloatVector, + }, + }, + Functions: []*schemapb.FunctionSchema{{ + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text"}, + InputFieldIds: []int64{100}, + OutputFieldNames: []string{"sparse"}, + OutputFieldIds: []int64{101}, + }}, + }, nil, &querypb.LoadMetaInfo{SchemaVersion: tsoutil.ComposeTSByTime(time.Now(), 0)}) + s.ResetDelegator() + + result, err := s.delegator.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Topks: []int64{1}, + Tasks: []*querypb.HighlightTask{ + { + FieldId: 100, + Texts: []string{"test document"}, + SearchTextNum: 0, + CorpusTextNum: 1, + }, + }, + }) + s.Require().NoError(err) + s.Require().NotNil(result) + }) +} + // TestDelegatorLifetimeIntegration tests the integration of lifetime state checks with main delegator methods func (s *DelegatorSuite) TestDelegatorLifetimeIntegration() { sd := s.delegator.(*shardDelegator) diff --git a/internal/querynodev2/delegator/mock_delegator.go b/internal/querynodev2/delegator/mock_delegator.go index 3d06d140e5..8f4ffeba45 100644 --- a/internal/querynodev2/delegator/mock_delegator.go +++ b/internal/querynodev2/delegator/mock_delegator.go @@ -289,6 +289,65 @@ func (_c *MockShardDelegator_GetDeleteBufferSize_Call) RunAndReturn(run func() ( return _c } +// GetHighlight provides a mock function with given fields: ctx, req +func (_m *MockShardDelegator) GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for GetHighlight") + } + + var r0 []*querypb.HighlightResult + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetHighlightRequest) []*querypb.HighlightResult); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*querypb.HighlightResult) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetHighlightRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockShardDelegator_GetHighlight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHighlight' +type MockShardDelegator_GetHighlight_Call struct { + *mock.Call +} + +// GetHighlight is a helper method to define mock.On call +// - ctx context.Context +// - req *querypb.GetHighlightRequest +func (_e *MockShardDelegator_Expecter) GetHighlight(ctx interface{}, req interface{}) *MockShardDelegator_GetHighlight_Call { + return &MockShardDelegator_GetHighlight_Call{Call: _e.mock.On("GetHighlight", ctx, req)} +} + +func (_c *MockShardDelegator_GetHighlight_Call) Run(run func(ctx context.Context, req *querypb.GetHighlightRequest)) *MockShardDelegator_GetHighlight_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.GetHighlightRequest)) + }) + return _c +} + +func (_c *MockShardDelegator_GetHighlight_Call) Return(_a0 []*querypb.HighlightResult, _a1 error) *MockShardDelegator_GetHighlight_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockShardDelegator_GetHighlight_Call) RunAndReturn(run func(context.Context, *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error)) *MockShardDelegator_GetHighlight_Call { + _c.Call.Return(run) + return _c +} + // GetPartitionStatsVersions provides a mock function with given fields: ctx func (_m *MockShardDelegator) GetPartitionStatsVersions(ctx context.Context) map[int64]int64 { ret := _m.Called(ctx) diff --git a/internal/querynodev2/delegator/util.go b/internal/querynodev2/delegator/util.go index 127c0436b6..54eb028aeb 100644 --- a/internal/querynodev2/delegator/util.go +++ b/internal/querynodev2/delegator/util.go @@ -2,7 +2,10 @@ package delegator import ( "fmt" + "sort" + "unicode/utf8" + "github.com/cockroachdb/errors" "go.uber.org/zap" "google.golang.org/protobuf/proto" @@ -10,7 +13,9 @@ import ( "github.com/milvus-io/milvus/pkg/v2/log" "github.com/milvus-io/milvus/pkg/v2/proto/internalpb" "github.com/milvus-io/milvus/pkg/v2/proto/planpb" + "github.com/milvus-io/milvus/pkg/v2/proto/querypb" "github.com/milvus-io/milvus/pkg/v2/util/merr" + "github.com/milvus-io/milvus/pkg/v2/util/typeutil" ) func BuildSparseFieldData(field *schemapb.FieldSchema, sparseArray *schemapb.SparseFloatArray) *schemapb.FieldData { @@ -62,3 +67,117 @@ func SetBM25Params(req *internalpb.SearchRequest, avgdl float64) error { } return nil } + +type ( + Span [2]int64 + SpanList []Span +) + +func (a SpanList) Len() int { return len(a) } +func (a SpanList) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a SpanList) Less(i, j int) bool { + if a[i][0] == a[j][0] { + return a[i][1] < a[j][1] + } + return a[i][0] < a[j][0] +} + +// merge repeated segments +func mergeOffsets(input SpanList) SpanList { + sort.Sort(input) + maxEndOffset := int64(-1) + offsets := SpanList{} + for _, pair := range input { + if pair[1] > maxEndOffset { + if len(offsets) == 0 || pair[0] > offsets[len(offsets)-1][1] { + // if start offset > max offset before, + // no any intersection with previous one, + // use all pair. + offsets = append(offsets, pair) + } else { + // if start offset <= max offset before, + // has intersection with previous one, + // merge two offset to one. + offsets[len(offsets)-1][1] = pair[1] + } + maxEndOffset = pair[1] + } + } + return offsets +} + +func bytesOffsetToRuneOffset(text string, spans SpanList) error { + byteOffsetSet := typeutil.NewSet[int64]() + for _, span := range spans { + byteOffsetSet.Insert(span[0]) + byteOffsetSet.Insert(span[1]) + } + offsetMap := map[int64]int64{0: 0, int64(len(text)): int64(utf8.RuneCountInString(text))} + + cnt := int64(0) + for i := range text { + if byteOffsetSet.Contain(int64(i)) { + offsetMap[int64(i)] = cnt + } + cnt++ + } + + // convert spans from byte offsets to rune offsets + for i, span := range spans { + startOffset, ok := offsetMap[span[0]] + if !ok { + return errors.Errorf("start offset: %d not found (text: %d bytes)", span[0], len(text)) + } + endOffset, ok := offsetMap[span[1]] + if !ok { + return errors.Errorf("end offset: %d not found (text: %d bytes)", span[1], len(text)) + } + spans[i][0] = startOffset + spans[i][1] = endOffset + } + return nil +} + +func fetchFragmentsFromOffsets(text string, spans SpanList, fragmentOffset int64, fragmentSize int64, numOfFragments int64) []*querypb.HighlightFragment { + result := make([]*querypb.HighlightFragment, 0) + textRuneLen := int64(utf8.RuneCountInString(text)) + + var frag *querypb.HighlightFragment = nil + next := func(span *Span) bool { + startOffset := max(0, span[0]-fragmentOffset) + endOffset := min(max(span[1], startOffset+fragmentSize), textRuneLen) + if frag != nil { + result = append(result, frag) + } + if len(result) >= int(numOfFragments) { + frag = nil + return false + } + frag = &querypb.HighlightFragment{ + StartOffset: startOffset, + EndOffset: endOffset, + Offsets: []int64{span[0], span[1]}, + } + return true + } + + for i, span := range spans { + if frag == nil || span[0] > frag.EndOffset { + if !next(&span) { + break + } + } else { + // append rune offset to fragment + frag.Offsets = append(frag.Offsets, spans[i][0], spans[i][1]) + // extend fragment end offset if this span goes beyond current boundary + if span[1] > frag.EndOffset { + frag.EndOffset = span[1] + } + } + } + + if frag != nil { + result = append(result, frag) + } + return result +} diff --git a/internal/querynodev2/delegator/util_test.go b/internal/querynodev2/delegator/util_test.go new file mode 100644 index 0000000000..1566b51c12 --- /dev/null +++ b/internal/querynodev2/delegator/util_test.go @@ -0,0 +1,38 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +package delegator + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestBytesOffsetToRuneOffset(t *testing.T) { + // test with chinese + text := "你好世界" // 12 bytes, 4 runes + spans := SpanList{{0, 6}, {6, 12}} + err := bytesOffsetToRuneOffset(text, spans) + assert.NoError(t, err) + assert.Equal(t, SpanList{{0, 2}, {2, 4}}, spans) + + // test with emoji + text = "Hello👋World" // 15 bytes, 11 runes + spans = SpanList{{0, 5}, {5, 9}, {9, 14}} + err = bytesOffsetToRuneOffset(text, spans) + assert.NoError(t, err) + assert.Equal(t, SpanList{{0, 5}, {5, 6}, {6, 11}}, spans) +} diff --git a/internal/querynodev2/services.go b/internal/querynodev2/services.go index 9a9f94c071..7f0f487a42 100644 --- a/internal/querynodev2/services.go +++ b/internal/querynodev2/services.go @@ -1667,3 +1667,36 @@ func (node *QueryNode) DropIndex(ctx context.Context, req *querypb.DropIndexRequ return merr.Success(), nil } + +func (node *QueryNode) GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest) (*querypb.GetHighlightResponse, error) { + // check node healthy + if err := node.lifetime.Add(merr.IsHealthy); err != nil { + return &querypb.GetHighlightResponse{ + Status: merr.Status(err), + }, nil + } + defer node.lifetime.Done() + + // get delegator + sd, ok := node.delegators.Get(req.GetChannel()) + if !ok { + err := merr.WrapErrChannelNotFound(req.GetChannel()) + log.Warn("GetHighlight failed, failed to get shard delegator", zap.Error(err)) + return &querypb.GetHighlightResponse{ + Status: merr.Status(err), + }, nil + } + + results, err := sd.GetHighlight(ctx, req) + if err != nil { + log.Warn("GetHighlight failed, delegator run failed", zap.Error(err)) + return &querypb.GetHighlightResponse{ + Status: merr.Status(err), + }, nil + } + + return &querypb.GetHighlightResponse{ + Status: merr.Success(), + Results: results, + }, nil +} diff --git a/internal/querynodev2/services_test.go b/internal/querynodev2/services_test.go index 4f359cf328..9f01cc7032 100644 --- a/internal/querynodev2/services_test.go +++ b/internal/querynodev2/services_test.go @@ -2417,6 +2417,49 @@ func (suite *ServiceSuite) TestRunAnalyzer() { }) } +func (suite *ServiceSuite) TestGetHighlight() { + ctx := context.Background() + + suite.Run("node not healthy", func() { + suite.node.UpdateStateCode(commonpb.StateCode_Abnormal) + defer suite.node.UpdateStateCode(commonpb.StateCode_Healthy) + + resp, err := suite.node.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Channel: suite.vchannel, + Topks: []int64{10}, + }) + + suite.NoError(err) + suite.Error(merr.Error(resp.GetStatus())) + }) + + suite.Run("normal case", func() { + delegator := &delegator.MockShardDelegator{} + suite.node.delegators.Insert(suite.vchannel, delegator) + defer suite.node.delegators.GetAndRemove(suite.vchannel) + delegator.EXPECT().GetHighlight(mock.Anything, mock.Anything).Return( + []*querypb.HighlightResult{}, nil) + resp, err := suite.node.GetHighlight(ctx, &querypb.GetHighlightRequest{ + Channel: suite.vchannel, + Topks: []int64{1, 1}, + Tasks: []*querypb.HighlightTask{ + { + FieldName: "text_field", + FieldId: 100, + Texts: []string{"target text", "target text2", "text", "text2"}, + AnalyzerNames: []string{"standard", "standard", "standard", "standard"}, + SearchTextNum: 2, + CorpusTextNum: 2, + }, + }, + }) + + suite.NoError(err) + suite.NoError(merr.Error(resp.GetStatus())) + suite.NotNil(resp.Results) + }) +} + func TestQueryNodeService(t *testing.T) { wal := mock_streaming.NewMockWALAccesser(t) local := mock_streaming.NewMockLocal(t) diff --git a/internal/util/mock/grpc_querynode_client.go b/internal/util/mock/grpc_querynode_client.go index c58b1e278b..1522c9db36 100644 --- a/internal/util/mock/grpc_querynode_client.go +++ b/internal/util/mock/grpc_querynode_client.go @@ -142,6 +142,10 @@ func (m *GrpcQueryNodeClient) RunAnalyzer(ctx context.Context, in *querypb.RunAn return &milvuspb.RunAnalyzerResponse{}, m.Err } +func (m *GrpcQueryNodeClient) GetHighlight(ctx context.Context, in *querypb.GetHighlightRequest, opts ...grpc.CallOption) (*querypb.GetHighlightResponse, error) { + return &querypb.GetHighlightResponse{}, m.Err +} + func (m *GrpcQueryNodeClient) Close() error { return m.Err } diff --git a/internal/util/wrappers/qn_wrapper.go b/internal/util/wrappers/qn_wrapper.go index d138d1c94b..28b5f63f59 100644 --- a/internal/util/wrappers/qn_wrapper.go +++ b/internal/util/wrappers/qn_wrapper.go @@ -160,6 +160,10 @@ func (qn *qnServerWrapper) RunAnalyzer(ctx context.Context, in *querypb.RunAnaly return qn.QueryNode.RunAnalyzer(ctx, in) } +func (qn *qnServerWrapper) GetHighlight(ctx context.Context, in *querypb.GetHighlightRequest, _ ...grpc.CallOption) (*querypb.GetHighlightResponse, error) { + return qn.QueryNode.GetHighlight(ctx, in) +} + func (qn *qnServerWrapper) DropIndex(ctx context.Context, in *querypb.DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return qn.QueryNode.DropIndex(ctx, in) } diff --git a/pkg/go.mod b/pkg/go.mod index 8c3280fb16..bf3bd27e2a 100644 --- a/pkg/go.mod +++ b/pkg/go.mod @@ -22,7 +22,7 @@ require ( github.com/jolestar/go-commons-pool/v2 v2.1.2 github.com/json-iterator/go v1.1.13-0.20220915233716-71ac16282d12 github.com/klauspost/compress v1.18.0 - github.com/milvus-io/milvus-proto/go-api/v2 v2.6.7 + github.com/milvus-io/milvus-proto/go-api/v2 v2.6.8-0.20251203092105-e2557263fc4c github.com/minio/minio-go/v7 v7.0.73 github.com/panjf2000/ants/v2 v2.11.3 github.com/prometheus/client_golang v1.20.5 diff --git a/pkg/go.sum b/pkg/go.sum index 499c51a8a4..a6dfb10f48 100644 --- a/pkg/go.sum +++ b/pkg/go.sum @@ -621,8 +621,8 @@ github.com/milvus-io/cgosymbolizer v0.0.0-20250318084424-114f4050c3a6 h1:YHMFI6L github.com/milvus-io/cgosymbolizer v0.0.0-20250318084424-114f4050c3a6/go.mod h1:DvXTE/K/RtHehxU8/GtDs4vFtfw64jJ3PaCnFri8CRg= github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b h1:TfeY0NxYxZzUfIfYe5qYDBzt4ZYRqzUjTR6CvUzjat8= github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b/go.mod h1:iwW+9cWfIzzDseEBCCeDSN5SD16Tidvy8cwQ7ZY8Qj4= -github.com/milvus-io/milvus-proto/go-api/v2 v2.6.7 h1:RJtZbkS5zKNIXxsqjGBUZc2SbnI4MGq+TfOfc8tJsuM= -github.com/milvus-io/milvus-proto/go-api/v2 v2.6.7/go.mod h1:/6UT4zZl6awVeXLeE7UGDWZvXj3IWkRsh3mqsn0DiAs= +github.com/milvus-io/milvus-proto/go-api/v2 v2.6.8-0.20251203092105-e2557263fc4c h1:Gh02wIJEI6RUbEXwZworPBfK9BYd1SVBIDHDL8GsrCY= +github.com/milvus-io/milvus-proto/go-api/v2 v2.6.8-0.20251203092105-e2557263fc4c/go.mod h1:/6UT4zZl6awVeXLeE7UGDWZvXj3IWkRsh3mqsn0DiAs= github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= github.com/minio/minio-go/v7 v7.0.73 h1:qr2vi96Qm7kZ4v7LLebjte+MQh621fFWnv93p12htEo= diff --git a/pkg/proto/query_coord.proto b/pkg/proto/query_coord.proto index b4ecf3ec87..3dbda4ae94 100644 --- a/pkg/proto/query_coord.proto +++ b/pkg/proto/query_coord.proto @@ -172,6 +172,8 @@ service QueryNode { rpc UpdateSchema(UpdateSchemaRequest) returns (common.Status) {} rpc RunAnalyzer(RunAnalyzerRequest) returns(milvus.RunAnalyzerResponse){} + rpc GetHighlight(GetHighlightRequest) returns (GetHighlightResponse){} + rpc DropIndex(DropIndexRequest) returns (common.Status) {} } @@ -995,6 +997,63 @@ message RunAnalyzerRequest{ bool with_hash = 7; } +message HighlightOptions{ + int64 fragment_size = 1; + int64 fragment_offset = 2; + int64 num_of_fragments = 3; +} + +enum HighlightQueryType{ + TextMatch = 0; +} + +message HighlightQuery{ + HighlightQueryType type = 1; +} + +// HighlightTask fetch highlight for all queries at one field +// search_text_num/search_num == len(topks) == nq +// corpus_text_num == sum(topks) == len(search_results) +message HighlightTask{ + string field_name = 1; + int64 field_id = 2; + // len(texts) = search_text_num + corpus_text_num + len(queries); + // text = search_text...corpus_text...query_text + repeated string texts = 3; + repeated string analyzer_names = 4; // used if field with multi-analyzer + + int64 search_text_num = 5; + int64 corpus_text_num = 6; + HighlightOptions options = 7; + repeated HighlightQuery queries = 8; +} + +// Get Lexical highlight from delegator +message GetHighlightRequest{ + common.MsgBase base = 1; + string channel = 2; + repeated int64 topks = 3; + repeated HighlightTask tasks=4; // one task for one field +} + +// start_offset and end_offset are fragment offset in the original text +// number of offsets always be 2 * number of highlight terms in the fragment +message HighlightFragment{ + int64 start_offset = 1; + int64 end_offset = 2; + // char offset of the highlight terms in the fragment + repeated int64 offsets = 3; +} + +message HighlightResult{ + repeated HighlightFragment fragments = 2; +} + +message GetHighlightResponse{ + common.Status status = 1; + repeated HighlightResult results = 2; +} + message ListLoadedSegmentsRequest { common.MsgBase base = 1; } diff --git a/pkg/proto/querypb/query_coord.pb.go b/pkg/proto/querypb/query_coord.pb.go index 19cbee995e..b37a4ffb47 100644 --- a/pkg/proto/querypb/query_coord.pb.go +++ b/pkg/proto/querypb/query_coord.pb.go @@ -401,6 +401,49 @@ func (SyncType) EnumDescriptor() ([]byte, []int) { return file_query_coord_proto_rawDescGZIP(), []int{6} } +type HighlightQueryType int32 + +const ( + HighlightQueryType_TextMatch HighlightQueryType = 0 +) + +// Enum value maps for HighlightQueryType. +var ( + HighlightQueryType_name = map[int32]string{ + 0: "TextMatch", + } + HighlightQueryType_value = map[string]int32{ + "TextMatch": 0, + } +) + +func (x HighlightQueryType) Enum() *HighlightQueryType { + p := new(HighlightQueryType) + *p = x + return p +} + +func (x HighlightQueryType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (HighlightQueryType) Descriptor() protoreflect.EnumDescriptor { + return file_query_coord_proto_enumTypes[7].Descriptor() +} + +func (HighlightQueryType) Type() protoreflect.EnumType { + return &file_query_coord_proto_enumTypes[7] +} + +func (x HighlightQueryType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use HighlightQueryType.Descriptor instead. +func (HighlightQueryType) EnumDescriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{7} +} + type ShowCollectionsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -7629,6 +7672,464 @@ func (x *RunAnalyzerRequest) GetWithHash() bool { return false } +type HighlightOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FragmentSize int64 `protobuf:"varint,1,opt,name=fragment_size,json=fragmentSize,proto3" json:"fragment_size,omitempty"` + FragmentOffset int64 `protobuf:"varint,2,opt,name=fragment_offset,json=fragmentOffset,proto3" json:"fragment_offset,omitempty"` + NumOfFragments int64 `protobuf:"varint,3,opt,name=num_of_fragments,json=numOfFragments,proto3" json:"num_of_fragments,omitempty"` +} + +func (x *HighlightOptions) Reset() { + *x = HighlightOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[90] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HighlightOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HighlightOptions) ProtoMessage() {} + +func (x *HighlightOptions) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[90] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HighlightOptions.ProtoReflect.Descriptor instead. +func (*HighlightOptions) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{90} +} + +func (x *HighlightOptions) GetFragmentSize() int64 { + if x != nil { + return x.FragmentSize + } + return 0 +} + +func (x *HighlightOptions) GetFragmentOffset() int64 { + if x != nil { + return x.FragmentOffset + } + return 0 +} + +func (x *HighlightOptions) GetNumOfFragments() int64 { + if x != nil { + return x.NumOfFragments + } + return 0 +} + +type HighlightQuery struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type HighlightQueryType `protobuf:"varint,1,opt,name=type,proto3,enum=milvus.proto.query.HighlightQueryType" json:"type,omitempty"` +} + +func (x *HighlightQuery) Reset() { + *x = HighlightQuery{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[91] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HighlightQuery) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HighlightQuery) ProtoMessage() {} + +func (x *HighlightQuery) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[91] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HighlightQuery.ProtoReflect.Descriptor instead. +func (*HighlightQuery) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{91} +} + +func (x *HighlightQuery) GetType() HighlightQueryType { + if x != nil { + return x.Type + } + return HighlightQueryType_TextMatch +} + +// HighlightTask fetch highlight for all queries at one field +// search_text_num/search_num == len(topks) == nq +// corpus_text_num == sum(topks) == len(search_results) +type HighlightTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FieldName string `protobuf:"bytes,1,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"` + FieldId int64 `protobuf:"varint,2,opt,name=field_id,json=fieldId,proto3" json:"field_id,omitempty"` + // len(texts) = search_text_num + corpus_text_num + len(queries); + // text = search_text...corpus_text...query_text + Texts []string `protobuf:"bytes,3,rep,name=texts,proto3" json:"texts,omitempty"` + AnalyzerNames []string `protobuf:"bytes,4,rep,name=analyzer_names,json=analyzerNames,proto3" json:"analyzer_names,omitempty"` // used if field with multi-analyzer + SearchTextNum int64 `protobuf:"varint,5,opt,name=search_text_num,json=searchTextNum,proto3" json:"search_text_num,omitempty"` + CorpusTextNum int64 `protobuf:"varint,6,opt,name=corpus_text_num,json=corpusTextNum,proto3" json:"corpus_text_num,omitempty"` + Options *HighlightOptions `protobuf:"bytes,7,opt,name=options,proto3" json:"options,omitempty"` + Queries []*HighlightQuery `protobuf:"bytes,8,rep,name=queries,proto3" json:"queries,omitempty"` +} + +func (x *HighlightTask) Reset() { + *x = HighlightTask{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[92] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HighlightTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HighlightTask) ProtoMessage() {} + +func (x *HighlightTask) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[92] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HighlightTask.ProtoReflect.Descriptor instead. +func (*HighlightTask) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{92} +} + +func (x *HighlightTask) GetFieldName() string { + if x != nil { + return x.FieldName + } + return "" +} + +func (x *HighlightTask) GetFieldId() int64 { + if x != nil { + return x.FieldId + } + return 0 +} + +func (x *HighlightTask) GetTexts() []string { + if x != nil { + return x.Texts + } + return nil +} + +func (x *HighlightTask) GetAnalyzerNames() []string { + if x != nil { + return x.AnalyzerNames + } + return nil +} + +func (x *HighlightTask) GetSearchTextNum() int64 { + if x != nil { + return x.SearchTextNum + } + return 0 +} + +func (x *HighlightTask) GetCorpusTextNum() int64 { + if x != nil { + return x.CorpusTextNum + } + return 0 +} + +func (x *HighlightTask) GetOptions() *HighlightOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *HighlightTask) GetQueries() []*HighlightQuery { + if x != nil { + return x.Queries + } + return nil +} + +// Get Lexical highlight from delegator +type GetHighlightRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + Channel string `protobuf:"bytes,2,opt,name=channel,proto3" json:"channel,omitempty"` + Topks []int64 `protobuf:"varint,3,rep,packed,name=topks,proto3" json:"topks,omitempty"` + Tasks []*HighlightTask `protobuf:"bytes,4,rep,name=tasks,proto3" json:"tasks,omitempty"` // one task for one field +} + +func (x *GetHighlightRequest) Reset() { + *x = GetHighlightRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[93] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetHighlightRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetHighlightRequest) ProtoMessage() {} + +func (x *GetHighlightRequest) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[93] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetHighlightRequest.ProtoReflect.Descriptor instead. +func (*GetHighlightRequest) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{93} +} + +func (x *GetHighlightRequest) GetBase() *commonpb.MsgBase { + if x != nil { + return x.Base + } + return nil +} + +func (x *GetHighlightRequest) GetChannel() string { + if x != nil { + return x.Channel + } + return "" +} + +func (x *GetHighlightRequest) GetTopks() []int64 { + if x != nil { + return x.Topks + } + return nil +} + +func (x *GetHighlightRequest) GetTasks() []*HighlightTask { + if x != nil { + return x.Tasks + } + return nil +} + +// start_offset and end_offset are fragment offset in the original text +// number of offsets always be 2 * number of highlight terms in the fragment +type HighlightFragment struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StartOffset int64 `protobuf:"varint,1,opt,name=start_offset,json=startOffset,proto3" json:"start_offset,omitempty"` + EndOffset int64 `protobuf:"varint,2,opt,name=end_offset,json=endOffset,proto3" json:"end_offset,omitempty"` + // char offset of the highlight terms in the fragment + Offsets []int64 `protobuf:"varint,3,rep,packed,name=offsets,proto3" json:"offsets,omitempty"` +} + +func (x *HighlightFragment) Reset() { + *x = HighlightFragment{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[94] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HighlightFragment) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HighlightFragment) ProtoMessage() {} + +func (x *HighlightFragment) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[94] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HighlightFragment.ProtoReflect.Descriptor instead. +func (*HighlightFragment) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{94} +} + +func (x *HighlightFragment) GetStartOffset() int64 { + if x != nil { + return x.StartOffset + } + return 0 +} + +func (x *HighlightFragment) GetEndOffset() int64 { + if x != nil { + return x.EndOffset + } + return 0 +} + +func (x *HighlightFragment) GetOffsets() []int64 { + if x != nil { + return x.Offsets + } + return nil +} + +type HighlightResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Fragments []*HighlightFragment `protobuf:"bytes,2,rep,name=fragments,proto3" json:"fragments,omitempty"` +} + +func (x *HighlightResult) Reset() { + *x = HighlightResult{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[95] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HighlightResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HighlightResult) ProtoMessage() {} + +func (x *HighlightResult) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[95] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HighlightResult.ProtoReflect.Descriptor instead. +func (*HighlightResult) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{95} +} + +func (x *HighlightResult) GetFragments() []*HighlightFragment { + if x != nil { + return x.Fragments + } + return nil +} + +type GetHighlightResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Results []*HighlightResult `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"` +} + +func (x *GetHighlightResponse) Reset() { + *x = GetHighlightResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[96] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetHighlightResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetHighlightResponse) ProtoMessage() {} + +func (x *GetHighlightResponse) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[96] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetHighlightResponse.ProtoReflect.Descriptor instead. +func (*GetHighlightResponse) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{96} +} + +func (x *GetHighlightResponse) GetStatus() *commonpb.Status { + if x != nil { + return x.Status + } + return nil +} + +func (x *GetHighlightResponse) GetResults() []*HighlightResult { + if x != nil { + return x.Results + } + return nil +} + type ListLoadedSegmentsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -7640,7 +8141,7 @@ type ListLoadedSegmentsRequest struct { func (x *ListLoadedSegmentsRequest) Reset() { *x = ListLoadedSegmentsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[90] + mi := &file_query_coord_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7653,7 +8154,7 @@ func (x *ListLoadedSegmentsRequest) String() string { func (*ListLoadedSegmentsRequest) ProtoMessage() {} func (x *ListLoadedSegmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[90] + mi := &file_query_coord_proto_msgTypes[97] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7666,7 +8167,7 @@ func (x *ListLoadedSegmentsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListLoadedSegmentsRequest.ProtoReflect.Descriptor instead. func (*ListLoadedSegmentsRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{90} + return file_query_coord_proto_rawDescGZIP(), []int{97} } func (x *ListLoadedSegmentsRequest) GetBase() *commonpb.MsgBase { @@ -7688,7 +8189,7 @@ type ListLoadedSegmentsResponse struct { func (x *ListLoadedSegmentsResponse) Reset() { *x = ListLoadedSegmentsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[91] + mi := &file_query_coord_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7701,7 +8202,7 @@ func (x *ListLoadedSegmentsResponse) String() string { func (*ListLoadedSegmentsResponse) ProtoMessage() {} func (x *ListLoadedSegmentsResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[91] + mi := &file_query_coord_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7714,7 +8215,7 @@ func (x *ListLoadedSegmentsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListLoadedSegmentsResponse.ProtoReflect.Descriptor instead. func (*ListLoadedSegmentsResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{91} + return file_query_coord_proto_rawDescGZIP(), []int{98} } func (x *ListLoadedSegmentsResponse) GetStatus() *commonpb.Status { @@ -7746,7 +8247,7 @@ type DropIndexRequest struct { func (x *DropIndexRequest) Reset() { *x = DropIndexRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[92] + mi := &file_query_coord_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7759,7 +8260,7 @@ func (x *DropIndexRequest) String() string { func (*DropIndexRequest) ProtoMessage() {} func (x *DropIndexRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[92] + mi := &file_query_coord_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7772,7 +8273,7 @@ func (x *DropIndexRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DropIndexRequest.ProtoReflect.Descriptor instead. func (*DropIndexRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{92} + return file_query_coord_proto_rawDescGZIP(), []int{99} } func (x *DropIndexRequest) GetBase() *commonpb.MsgBase { @@ -9360,66 +9861,136 @@ var file_query_coord_proto_rawDesc = []byte{ 0x0a, 0x0b, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x77, 0x69, 0x74, 0x68, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x08, 0x77, 0x69, 0x74, 0x68, 0x48, 0x61, 0x73, 0x68, 0x22, 0x4d, 0x0a, 0x19, - 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, - 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x71, 0x0a, 0x1a, 0x4c, - 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1e, - 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x22, 0xbd, - 0x01, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, - 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x73, 0x12, - 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x65, - 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x0c, 0x6e, 0x65, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2a, 0x36, - 0x0a, 0x09, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x46, - 0x75, 0x6c, 0x6c, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x10, 0x01, - 0x12, 0x09, 0x0a, 0x05, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x53, - 0x74, 0x61, 0x74, 0x73, 0x10, 0x03, 0x2a, 0x40, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, - 0x6f, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, - 0x12, 0x07, 0x0a, 0x03, 0x41, 0x6c, 0x6c, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x74, 0x72, - 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x48, 0x69, 0x73, 0x74, - 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x10, 0x03, 0x2a, 0x7a, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, - 0x74, 0x45, 0x78, 0x69, 0x73, 0x74, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x6f, 0x74, 0x50, - 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x6e, 0x44, 0x69, - 0x73, 0x6b, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, - 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x6e, 0x4d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0x04, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x61, 0x72, 0x74, 0x69, - 0x61, 0x6c, 0x49, 0x6e, 0x47, 0x50, 0x55, 0x10, 0x05, 0x12, 0x09, 0x0a, 0x05, 0x49, 0x6e, 0x47, - 0x50, 0x55, 0x10, 0x06, 0x2a, 0x64, 0x0a, 0x10, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x43, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x55, 0x6e, 0x4b, 0x6e, - 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x00, 0x12, 0x0b, 0x0a, - 0x07, 0x48, 0x61, 0x6e, 0x64, 0x6f, 0x66, 0x66, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x4c, 0x6f, - 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x47, - 0x72, 0x70, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, - 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x6f, 0x77, 0x6e, 0x10, 0x04, 0x2a, 0x42, 0x0a, 0x08, 0x4c, 0x6f, - 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, - 0x6e, 0x54, 0x79, 0x70, 0x65, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x4c, 0x6f, 0x61, 0x64, 0x50, - 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x6f, - 0x61, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x02, 0x2a, 0x32, - 0x0a, 0x0a, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, - 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x6f, 0x61, - 0x64, 0x69, 0x6e, 0x67, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, - 0x10, 0x02, 0x2a, 0x57, 0x0a, 0x08, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, - 0x0a, 0x06, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x65, - 0x74, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x6d, 0x65, 0x6e, 0x64, 0x10, 0x02, 0x12, 0x11, - 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x10, - 0x03, 0x12, 0x18, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x10, 0x04, 0x32, 0x81, 0x1e, 0x0a, 0x0a, + 0x28, 0x08, 0x52, 0x08, 0x77, 0x69, 0x74, 0x68, 0x48, 0x61, 0x73, 0x68, 0x22, 0x8a, 0x01, 0x0a, + 0x10, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, + 0x7a, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, + 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x6f, 0x66, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x4f, 0x66, + 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x4c, 0x0a, 0x0e, 0x48, 0x69, 0x67, + 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x48, + 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xd4, 0x02, 0x0a, 0x0d, 0x48, 0x69, 0x67, 0x68, + 0x6c, 0x69, 0x67, 0x68, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x1d, 0x0a, 0x0a, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x65, 0x78, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x05, 0x74, 0x65, 0x78, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x61, 0x6e, 0x61, + 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0d, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x73, + 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x5f, + 0x6e, 0x75, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x73, 0x65, 0x61, 0x72, 0x63, + 0x68, 0x54, 0x65, 0x78, 0x74, 0x4e, 0x75, 0x6d, 0x12, 0x26, 0x0a, 0x0f, 0x63, 0x6f, 0x72, 0x70, + 0x75, 0x73, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x6e, 0x75, 0x6d, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0d, 0x63, 0x6f, 0x72, 0x70, 0x75, 0x73, 0x54, 0x65, 0x78, 0x74, 0x4e, 0x75, 0x6d, + 0x12, 0x3e, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x12, 0x3c, 0x0a, 0x07, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x07, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x22, 0xb0, + 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, + 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, + 0x65, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x6b, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x6b, 0x73, 0x12, 0x37, 0x0a, 0x05, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x48, 0x69, 0x67, + 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x05, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x22, 0x6f, 0x0a, 0x11, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x46, 0x72, + 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x6e, 0x64, + 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x65, + 0x6e, 0x64, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x66, 0x66, 0x73, + 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x6f, 0x66, 0x66, 0x73, 0x65, + 0x74, 0x73, 0x22, 0x56, 0x0a, 0x0f, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x43, 0x0a, 0x09, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x48, 0x69, + 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, + 0x09, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x8a, 0x01, 0x0a, 0x14, 0x47, + 0x65, 0x74, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3d, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x48, + 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x4d, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x4c, + 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, + 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x71, 0x0a, 0x1a, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x6f, + 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, + 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x22, 0xbd, 0x01, 0x0a, 0x10, 0x44, 0x72, + 0x6f, 0x70, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, + 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, + 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x1a, + 0x0a, 0x08, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, + 0x52, 0x08, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, + 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, + 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6e, 0x65, 0x65, + 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2a, 0x36, 0x0a, 0x09, 0x4c, 0x6f, 0x61, + 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x46, 0x75, 0x6c, 0x6c, 0x10, 0x00, + 0x12, 0x09, 0x0a, 0x05, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x49, + 0x6e, 0x64, 0x65, 0x78, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x74, 0x61, 0x74, 0x73, 0x10, + 0x03, 0x2a, 0x40, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x0b, + 0x0a, 0x07, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, + 0x6c, 0x6c, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, + 0x67, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, + 0x6c, 0x10, 0x03, 0x2a, 0x7a, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x74, 0x45, 0x78, 0x69, 0x73, + 0x74, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x6f, 0x74, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, + 0x74, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x6e, 0x44, 0x69, 0x73, 0x6b, 0x10, 0x02, 0x12, + 0x13, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, + 0x72, 0x79, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x10, 0x04, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x47, + 0x50, 0x55, 0x10, 0x05, 0x12, 0x09, 0x0a, 0x05, 0x49, 0x6e, 0x47, 0x50, 0x55, 0x10, 0x06, 0x2a, + 0x64, 0x0a, 0x10, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x48, 0x61, 0x6e, 0x64, + 0x6f, 0x66, 0x66, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x47, 0x72, 0x70, 0x63, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x44, + 0x6f, 0x77, 0x6e, 0x10, 0x04, 0x2a, 0x42, 0x0a, 0x08, 0x4c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, + 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x02, 0x2a, 0x32, 0x0a, 0x0a, 0x4c, 0x6f, 0x61, + 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x6e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x10, + 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x10, 0x02, 0x2a, 0x57, 0x0a, + 0x08, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x52, 0x65, 0x6d, + 0x6f, 0x76, 0x65, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x65, 0x74, 0x10, 0x01, 0x12, 0x09, + 0x0a, 0x05, 0x41, 0x6d, 0x65, 0x6e, 0x64, 0x10, 0x02, 0x12, 0x11, 0x0a, 0x0d, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x10, 0x04, 0x2a, 0x23, 0x0a, 0x12, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, + 0x67, 0x68, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0d, 0x0a, 0x09, + 0x54, 0x65, 0x78, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x00, 0x32, 0x81, 0x1e, 0x0a, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x12, 0x70, 0x0a, 0x13, 0x53, 0x68, 0x6f, 0x77, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, @@ -9660,7 +10231,7 @@ var file_query_coord_proto_rawDesc = []byte{ 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x32, - 0xc0, 0x15, 0x0a, 0x09, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x6c, 0x0a, + 0xa5, 0x16, 0x0a, 0x09, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x6c, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, @@ -9827,15 +10398,22 @@ var file_query_coord_proto_rawDesc = []byte{ 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x52, 0x75, 0x6e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x50, 0x0a, 0x09, 0x44, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x24, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x22, 0x00, 0x42, 0x32, 0x5a, 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, - 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x12, 0x63, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, + 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, + 0x65, 0x74, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x50, 0x0a, 0x09, 0x44, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x64, + 0x65, 0x78, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x64, 0x65, + 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x42, 0x32, 0x5a, 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, } var ( @@ -9850,8 +10428,8 @@ func file_query_coord_proto_rawDescGZIP() []byte { return file_query_coord_proto_rawDescData } -var file_query_coord_proto_enumTypes = make([]protoimpl.EnumInfo, 7) -var file_query_coord_proto_msgTypes = make([]protoimpl.MessageInfo, 114) +var file_query_coord_proto_enumTypes = make([]protoimpl.EnumInfo, 8) +var file_query_coord_proto_msgTypes = make([]protoimpl.MessageInfo, 121) var file_query_coord_proto_goTypes = []interface{}{ (LoadScope)(0), // 0: milvus.proto.query.LoadScope (DataScope)(0), // 1: milvus.proto.query.DataScope @@ -9860,480 +10438,498 @@ var file_query_coord_proto_goTypes = []interface{}{ (LoadType)(0), // 4: milvus.proto.query.LoadType (LoadStatus)(0), // 5: milvus.proto.query.LoadStatus (SyncType)(0), // 6: milvus.proto.query.SyncType - (*ShowCollectionsRequest)(nil), // 7: milvus.proto.query.ShowCollectionsRequest - (*ShowCollectionsResponse)(nil), // 8: milvus.proto.query.ShowCollectionsResponse - (*ShowPartitionsRequest)(nil), // 9: milvus.proto.query.ShowPartitionsRequest - (*ShowPartitionsResponse)(nil), // 10: milvus.proto.query.ShowPartitionsResponse - (*LoadCollectionRequest)(nil), // 11: milvus.proto.query.LoadCollectionRequest - (*ReleaseCollectionRequest)(nil), // 12: milvus.proto.query.ReleaseCollectionRequest - (*GetStatisticsRequest)(nil), // 13: milvus.proto.query.GetStatisticsRequest - (*LoadPartitionsRequest)(nil), // 14: milvus.proto.query.LoadPartitionsRequest - (*ReleasePartitionsRequest)(nil), // 15: milvus.proto.query.ReleasePartitionsRequest - (*GetPartitionStatesRequest)(nil), // 16: milvus.proto.query.GetPartitionStatesRequest - (*GetPartitionStatesResponse)(nil), // 17: milvus.proto.query.GetPartitionStatesResponse - (*GetSegmentInfoRequest)(nil), // 18: milvus.proto.query.GetSegmentInfoRequest - (*GetSegmentInfoResponse)(nil), // 19: milvus.proto.query.GetSegmentInfoResponse - (*GetShardLeadersRequest)(nil), // 20: milvus.proto.query.GetShardLeadersRequest - (*GetShardLeadersResponse)(nil), // 21: milvus.proto.query.GetShardLeadersResponse - (*UpdateResourceGroupsRequest)(nil), // 22: milvus.proto.query.UpdateResourceGroupsRequest - (*ShardLeadersList)(nil), // 23: milvus.proto.query.ShardLeadersList - (*SyncNewCreatedPartitionRequest)(nil), // 24: milvus.proto.query.SyncNewCreatedPartitionRequest - (*LoadMetaInfo)(nil), // 25: milvus.proto.query.LoadMetaInfo - (*WatchDmChannelsRequest)(nil), // 26: milvus.proto.query.WatchDmChannelsRequest - (*UnsubDmChannelRequest)(nil), // 27: milvus.proto.query.UnsubDmChannelRequest - (*SegmentLoadInfo)(nil), // 28: milvus.proto.query.SegmentLoadInfo - (*FieldIndexInfo)(nil), // 29: milvus.proto.query.FieldIndexInfo - (*JsonStatsInfo)(nil), // 30: milvus.proto.query.JsonStatsInfo - (*LoadSegmentsRequest)(nil), // 31: milvus.proto.query.LoadSegmentsRequest - (*ReleaseSegmentsRequest)(nil), // 32: milvus.proto.query.ReleaseSegmentsRequest - (*SearchRequest)(nil), // 33: milvus.proto.query.SearchRequest - (*QueryRequest)(nil), // 34: milvus.proto.query.QueryRequest - (*SyncReplicaSegmentsRequest)(nil), // 35: milvus.proto.query.SyncReplicaSegmentsRequest - (*ReplicaSegmentsInfo)(nil), // 36: milvus.proto.query.ReplicaSegmentsInfo - (*GetLoadInfoRequest)(nil), // 37: milvus.proto.query.GetLoadInfoRequest - (*GetLoadInfoResponse)(nil), // 38: milvus.proto.query.GetLoadInfoResponse - (*HandoffSegmentsRequest)(nil), // 39: milvus.proto.query.HandoffSegmentsRequest - (*LoadBalanceRequest)(nil), // 40: milvus.proto.query.LoadBalanceRequest - (*DmChannelWatchInfo)(nil), // 41: milvus.proto.query.DmChannelWatchInfo - (*QueryChannelInfo)(nil), // 42: milvus.proto.query.QueryChannelInfo - (*PartitionStates)(nil), // 43: milvus.proto.query.PartitionStates - (*SegmentInfo)(nil), // 44: milvus.proto.query.SegmentInfo - (*CollectionInfo)(nil), // 45: milvus.proto.query.CollectionInfo - (*UnsubscribeChannels)(nil), // 46: milvus.proto.query.UnsubscribeChannels - (*UnsubscribeChannelInfo)(nil), // 47: milvus.proto.query.UnsubscribeChannelInfo - (*SegmentChangeInfo)(nil), // 48: milvus.proto.query.SegmentChangeInfo - (*SealedSegmentsChangeInfo)(nil), // 49: milvus.proto.query.SealedSegmentsChangeInfo - (*GetDataDistributionRequest)(nil), // 50: milvus.proto.query.GetDataDistributionRequest - (*GetDataDistributionResponse)(nil), // 51: milvus.proto.query.GetDataDistributionResponse - (*LeaderView)(nil), // 52: milvus.proto.query.LeaderView - (*LeaderViewStatus)(nil), // 53: milvus.proto.query.LeaderViewStatus - (*SegmentDist)(nil), // 54: milvus.proto.query.SegmentDist - (*SegmentVersionInfo)(nil), // 55: milvus.proto.query.SegmentVersionInfo - (*ChannelVersionInfo)(nil), // 56: milvus.proto.query.ChannelVersionInfo - (*CollectionLoadInfo)(nil), // 57: milvus.proto.query.CollectionLoadInfo - (*PartitionLoadInfo)(nil), // 58: milvus.proto.query.PartitionLoadInfo - (*ChannelNodeInfo)(nil), // 59: milvus.proto.query.ChannelNodeInfo - (*Replica)(nil), // 60: milvus.proto.query.Replica - (*SyncAction)(nil), // 61: milvus.proto.query.SyncAction - (*SyncDistributionRequest)(nil), // 62: milvus.proto.query.SyncDistributionRequest - (*ResourceGroup)(nil), // 63: milvus.proto.query.ResourceGroup - (*TransferReplicaRequest)(nil), // 64: milvus.proto.query.TransferReplicaRequest - (*DescribeResourceGroupRequest)(nil), // 65: milvus.proto.query.DescribeResourceGroupRequest - (*DescribeResourceGroupResponse)(nil), // 66: milvus.proto.query.DescribeResourceGroupResponse - (*ResourceGroupInfo)(nil), // 67: milvus.proto.query.ResourceGroupInfo - (*DeleteRequest)(nil), // 68: milvus.proto.query.DeleteRequest - (*DeleteBatchRequest)(nil), // 69: milvus.proto.query.DeleteBatchRequest - (*DeleteBatchResponse)(nil), // 70: milvus.proto.query.DeleteBatchResponse - (*ActivateCheckerRequest)(nil), // 71: milvus.proto.query.ActivateCheckerRequest - (*DeactivateCheckerRequest)(nil), // 72: milvus.proto.query.DeactivateCheckerRequest - (*ListCheckersRequest)(nil), // 73: milvus.proto.query.ListCheckersRequest - (*ListCheckersResponse)(nil), // 74: milvus.proto.query.ListCheckersResponse - (*CheckerInfo)(nil), // 75: milvus.proto.query.CheckerInfo - (*SegmentTarget)(nil), // 76: milvus.proto.query.SegmentTarget - (*PartitionTarget)(nil), // 77: milvus.proto.query.PartitionTarget - (*ChannelTarget)(nil), // 78: milvus.proto.query.ChannelTarget - (*CollectionTarget)(nil), // 79: milvus.proto.query.CollectionTarget - (*NodeInfo)(nil), // 80: milvus.proto.query.NodeInfo - (*ListQueryNodeRequest)(nil), // 81: milvus.proto.query.ListQueryNodeRequest - (*ListQueryNodeResponse)(nil), // 82: milvus.proto.query.ListQueryNodeResponse - (*GetQueryNodeDistributionRequest)(nil), // 83: milvus.proto.query.GetQueryNodeDistributionRequest - (*GetQueryNodeDistributionResponse)(nil), // 84: milvus.proto.query.GetQueryNodeDistributionResponse - (*SuspendBalanceRequest)(nil), // 85: milvus.proto.query.SuspendBalanceRequest - (*ResumeBalanceRequest)(nil), // 86: milvus.proto.query.ResumeBalanceRequest - (*CheckBalanceStatusRequest)(nil), // 87: milvus.proto.query.CheckBalanceStatusRequest - (*CheckBalanceStatusResponse)(nil), // 88: milvus.proto.query.CheckBalanceStatusResponse - (*SuspendNodeRequest)(nil), // 89: milvus.proto.query.SuspendNodeRequest - (*ResumeNodeRequest)(nil), // 90: milvus.proto.query.ResumeNodeRequest - (*TransferSegmentRequest)(nil), // 91: milvus.proto.query.TransferSegmentRequest - (*TransferChannelRequest)(nil), // 92: milvus.proto.query.TransferChannelRequest - (*CheckQueryNodeDistributionRequest)(nil), // 93: milvus.proto.query.CheckQueryNodeDistributionRequest - (*UpdateLoadConfigRequest)(nil), // 94: milvus.proto.query.UpdateLoadConfigRequest - (*UpdateSchemaRequest)(nil), // 95: milvus.proto.query.UpdateSchemaRequest - (*RunAnalyzerRequest)(nil), // 96: milvus.proto.query.RunAnalyzerRequest - (*ListLoadedSegmentsRequest)(nil), // 97: milvus.proto.query.ListLoadedSegmentsRequest - (*ListLoadedSegmentsResponse)(nil), // 98: milvus.proto.query.ListLoadedSegmentsResponse - (*DropIndexRequest)(nil), // 99: milvus.proto.query.DropIndexRequest - nil, // 100: milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry - nil, // 101: milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry - nil, // 102: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry - nil, // 103: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry - nil, // 104: milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry - nil, // 105: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry - nil, // 106: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry - nil, // 107: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry - nil, // 108: milvus.proto.query.LeaderView.SegmentDistEntry - nil, // 109: milvus.proto.query.LeaderView.GrowingSegmentsEntry - nil, // 110: milvus.proto.query.LeaderView.PartitionStatsVersionsEntry - nil, // 111: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry - nil, // 112: milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry - nil, // 113: milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry - nil, // 114: milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry - nil, // 115: milvus.proto.query.Replica.ChannelNodeInfosEntry - nil, // 116: milvus.proto.query.SyncAction.PartitionStatsVersionsEntry - nil, // 117: milvus.proto.query.SyncAction.SealedSegmentRowCountEntry - nil, // 118: milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry - nil, // 119: milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry - nil, // 120: milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry - (*commonpb.MsgBase)(nil), // 121: milvus.proto.common.MsgBase - (*commonpb.Status)(nil), // 122: milvus.proto.common.Status - (*schemapb.LongArray)(nil), // 123: milvus.proto.schema.LongArray - (*schemapb.CollectionSchema)(nil), // 124: milvus.proto.schema.CollectionSchema - (commonpb.LoadPriority)(0), // 125: milvus.proto.common.LoadPriority - (*internalpb.GetStatisticsRequest)(nil), // 126: milvus.proto.internal.GetStatisticsRequest - (*indexpb.IndexInfo)(nil), // 127: milvus.proto.index.IndexInfo - (*commonpb.KeyValuePair)(nil), // 128: milvus.proto.common.KeyValuePair - (*datapb.VchannelInfo)(nil), // 129: milvus.proto.data.VchannelInfo - (*datapb.SegmentInfo)(nil), // 130: milvus.proto.data.SegmentInfo - (*datapb.FieldBinlog)(nil), // 131: milvus.proto.data.FieldBinlog - (*msgpb.MsgPosition)(nil), // 132: milvus.proto.msg.MsgPosition - (datapb.SegmentLevel)(0), // 133: milvus.proto.data.SegmentLevel - (*internalpb.SearchRequest)(nil), // 134: milvus.proto.internal.SearchRequest - (*internalpb.RetrieveRequest)(nil), // 135: milvus.proto.internal.RetrieveRequest - (commonpb.SegmentState)(0), // 136: milvus.proto.common.SegmentState - (*rgpb.ResourceGroupConfig)(nil), // 137: milvus.proto.rg.ResourceGroupConfig - (*commonpb.NodeInfo)(nil), // 138: milvus.proto.common.NodeInfo - (*schemapb.IDs)(nil), // 139: milvus.proto.schema.IDs - (*datapb.TextIndexStats)(nil), // 140: milvus.proto.data.TextIndexStats - (*datapb.JsonKeyStats)(nil), // 141: milvus.proto.data.JsonKeyStats - (*internalpb.ShowConfigurationsRequest)(nil), // 142: milvus.proto.internal.ShowConfigurationsRequest - (*milvuspb.GetMetricsRequest)(nil), // 143: milvus.proto.milvus.GetMetricsRequest - (*milvuspb.GetReplicasRequest)(nil), // 144: milvus.proto.milvus.GetReplicasRequest - (*milvuspb.CheckHealthRequest)(nil), // 145: milvus.proto.milvus.CheckHealthRequest - (*milvuspb.CreateResourceGroupRequest)(nil), // 146: milvus.proto.milvus.CreateResourceGroupRequest - (*milvuspb.DropResourceGroupRequest)(nil), // 147: milvus.proto.milvus.DropResourceGroupRequest - (*milvuspb.TransferNodeRequest)(nil), // 148: milvus.proto.milvus.TransferNodeRequest - (*milvuspb.ListResourceGroupsRequest)(nil), // 149: milvus.proto.milvus.ListResourceGroupsRequest - (*milvuspb.GetComponentStatesRequest)(nil), // 150: milvus.proto.milvus.GetComponentStatesRequest - (*internalpb.GetTimeTickChannelRequest)(nil), // 151: milvus.proto.internal.GetTimeTickChannelRequest - (*internalpb.GetStatisticsChannelRequest)(nil), // 152: milvus.proto.internal.GetStatisticsChannelRequest - (*internalpb.ShowConfigurationsResponse)(nil), // 153: milvus.proto.internal.ShowConfigurationsResponse - (*milvuspb.GetMetricsResponse)(nil), // 154: milvus.proto.milvus.GetMetricsResponse - (*milvuspb.GetReplicasResponse)(nil), // 155: milvus.proto.milvus.GetReplicasResponse - (*milvuspb.CheckHealthResponse)(nil), // 156: milvus.proto.milvus.CheckHealthResponse - (*milvuspb.ListResourceGroupsResponse)(nil), // 157: milvus.proto.milvus.ListResourceGroupsResponse - (*milvuspb.ComponentStates)(nil), // 158: milvus.proto.milvus.ComponentStates - (*milvuspb.StringResponse)(nil), // 159: milvus.proto.milvus.StringResponse - (*internalpb.GetStatisticsResponse)(nil), // 160: milvus.proto.internal.GetStatisticsResponse - (*internalpb.SearchResults)(nil), // 161: milvus.proto.internal.SearchResults - (*internalpb.RetrieveResults)(nil), // 162: milvus.proto.internal.RetrieveResults - (*milvuspb.RunAnalyzerResponse)(nil), // 163: milvus.proto.milvus.RunAnalyzerResponse + (HighlightQueryType)(0), // 7: milvus.proto.query.HighlightQueryType + (*ShowCollectionsRequest)(nil), // 8: milvus.proto.query.ShowCollectionsRequest + (*ShowCollectionsResponse)(nil), // 9: milvus.proto.query.ShowCollectionsResponse + (*ShowPartitionsRequest)(nil), // 10: milvus.proto.query.ShowPartitionsRequest + (*ShowPartitionsResponse)(nil), // 11: milvus.proto.query.ShowPartitionsResponse + (*LoadCollectionRequest)(nil), // 12: milvus.proto.query.LoadCollectionRequest + (*ReleaseCollectionRequest)(nil), // 13: milvus.proto.query.ReleaseCollectionRequest + (*GetStatisticsRequest)(nil), // 14: milvus.proto.query.GetStatisticsRequest + (*LoadPartitionsRequest)(nil), // 15: milvus.proto.query.LoadPartitionsRequest + (*ReleasePartitionsRequest)(nil), // 16: milvus.proto.query.ReleasePartitionsRequest + (*GetPartitionStatesRequest)(nil), // 17: milvus.proto.query.GetPartitionStatesRequest + (*GetPartitionStatesResponse)(nil), // 18: milvus.proto.query.GetPartitionStatesResponse + (*GetSegmentInfoRequest)(nil), // 19: milvus.proto.query.GetSegmentInfoRequest + (*GetSegmentInfoResponse)(nil), // 20: milvus.proto.query.GetSegmentInfoResponse + (*GetShardLeadersRequest)(nil), // 21: milvus.proto.query.GetShardLeadersRequest + (*GetShardLeadersResponse)(nil), // 22: milvus.proto.query.GetShardLeadersResponse + (*UpdateResourceGroupsRequest)(nil), // 23: milvus.proto.query.UpdateResourceGroupsRequest + (*ShardLeadersList)(nil), // 24: milvus.proto.query.ShardLeadersList + (*SyncNewCreatedPartitionRequest)(nil), // 25: milvus.proto.query.SyncNewCreatedPartitionRequest + (*LoadMetaInfo)(nil), // 26: milvus.proto.query.LoadMetaInfo + (*WatchDmChannelsRequest)(nil), // 27: milvus.proto.query.WatchDmChannelsRequest + (*UnsubDmChannelRequest)(nil), // 28: milvus.proto.query.UnsubDmChannelRequest + (*SegmentLoadInfo)(nil), // 29: milvus.proto.query.SegmentLoadInfo + (*FieldIndexInfo)(nil), // 30: milvus.proto.query.FieldIndexInfo + (*JsonStatsInfo)(nil), // 31: milvus.proto.query.JsonStatsInfo + (*LoadSegmentsRequest)(nil), // 32: milvus.proto.query.LoadSegmentsRequest + (*ReleaseSegmentsRequest)(nil), // 33: milvus.proto.query.ReleaseSegmentsRequest + (*SearchRequest)(nil), // 34: milvus.proto.query.SearchRequest + (*QueryRequest)(nil), // 35: milvus.proto.query.QueryRequest + (*SyncReplicaSegmentsRequest)(nil), // 36: milvus.proto.query.SyncReplicaSegmentsRequest + (*ReplicaSegmentsInfo)(nil), // 37: milvus.proto.query.ReplicaSegmentsInfo + (*GetLoadInfoRequest)(nil), // 38: milvus.proto.query.GetLoadInfoRequest + (*GetLoadInfoResponse)(nil), // 39: milvus.proto.query.GetLoadInfoResponse + (*HandoffSegmentsRequest)(nil), // 40: milvus.proto.query.HandoffSegmentsRequest + (*LoadBalanceRequest)(nil), // 41: milvus.proto.query.LoadBalanceRequest + (*DmChannelWatchInfo)(nil), // 42: milvus.proto.query.DmChannelWatchInfo + (*QueryChannelInfo)(nil), // 43: milvus.proto.query.QueryChannelInfo + (*PartitionStates)(nil), // 44: milvus.proto.query.PartitionStates + (*SegmentInfo)(nil), // 45: milvus.proto.query.SegmentInfo + (*CollectionInfo)(nil), // 46: milvus.proto.query.CollectionInfo + (*UnsubscribeChannels)(nil), // 47: milvus.proto.query.UnsubscribeChannels + (*UnsubscribeChannelInfo)(nil), // 48: milvus.proto.query.UnsubscribeChannelInfo + (*SegmentChangeInfo)(nil), // 49: milvus.proto.query.SegmentChangeInfo + (*SealedSegmentsChangeInfo)(nil), // 50: milvus.proto.query.SealedSegmentsChangeInfo + (*GetDataDistributionRequest)(nil), // 51: milvus.proto.query.GetDataDistributionRequest + (*GetDataDistributionResponse)(nil), // 52: milvus.proto.query.GetDataDistributionResponse + (*LeaderView)(nil), // 53: milvus.proto.query.LeaderView + (*LeaderViewStatus)(nil), // 54: milvus.proto.query.LeaderViewStatus + (*SegmentDist)(nil), // 55: milvus.proto.query.SegmentDist + (*SegmentVersionInfo)(nil), // 56: milvus.proto.query.SegmentVersionInfo + (*ChannelVersionInfo)(nil), // 57: milvus.proto.query.ChannelVersionInfo + (*CollectionLoadInfo)(nil), // 58: milvus.proto.query.CollectionLoadInfo + (*PartitionLoadInfo)(nil), // 59: milvus.proto.query.PartitionLoadInfo + (*ChannelNodeInfo)(nil), // 60: milvus.proto.query.ChannelNodeInfo + (*Replica)(nil), // 61: milvus.proto.query.Replica + (*SyncAction)(nil), // 62: milvus.proto.query.SyncAction + (*SyncDistributionRequest)(nil), // 63: milvus.proto.query.SyncDistributionRequest + (*ResourceGroup)(nil), // 64: milvus.proto.query.ResourceGroup + (*TransferReplicaRequest)(nil), // 65: milvus.proto.query.TransferReplicaRequest + (*DescribeResourceGroupRequest)(nil), // 66: milvus.proto.query.DescribeResourceGroupRequest + (*DescribeResourceGroupResponse)(nil), // 67: milvus.proto.query.DescribeResourceGroupResponse + (*ResourceGroupInfo)(nil), // 68: milvus.proto.query.ResourceGroupInfo + (*DeleteRequest)(nil), // 69: milvus.proto.query.DeleteRequest + (*DeleteBatchRequest)(nil), // 70: milvus.proto.query.DeleteBatchRequest + (*DeleteBatchResponse)(nil), // 71: milvus.proto.query.DeleteBatchResponse + (*ActivateCheckerRequest)(nil), // 72: milvus.proto.query.ActivateCheckerRequest + (*DeactivateCheckerRequest)(nil), // 73: milvus.proto.query.DeactivateCheckerRequest + (*ListCheckersRequest)(nil), // 74: milvus.proto.query.ListCheckersRequest + (*ListCheckersResponse)(nil), // 75: milvus.proto.query.ListCheckersResponse + (*CheckerInfo)(nil), // 76: milvus.proto.query.CheckerInfo + (*SegmentTarget)(nil), // 77: milvus.proto.query.SegmentTarget + (*PartitionTarget)(nil), // 78: milvus.proto.query.PartitionTarget + (*ChannelTarget)(nil), // 79: milvus.proto.query.ChannelTarget + (*CollectionTarget)(nil), // 80: milvus.proto.query.CollectionTarget + (*NodeInfo)(nil), // 81: milvus.proto.query.NodeInfo + (*ListQueryNodeRequest)(nil), // 82: milvus.proto.query.ListQueryNodeRequest + (*ListQueryNodeResponse)(nil), // 83: milvus.proto.query.ListQueryNodeResponse + (*GetQueryNodeDistributionRequest)(nil), // 84: milvus.proto.query.GetQueryNodeDistributionRequest + (*GetQueryNodeDistributionResponse)(nil), // 85: milvus.proto.query.GetQueryNodeDistributionResponse + (*SuspendBalanceRequest)(nil), // 86: milvus.proto.query.SuspendBalanceRequest + (*ResumeBalanceRequest)(nil), // 87: milvus.proto.query.ResumeBalanceRequest + (*CheckBalanceStatusRequest)(nil), // 88: milvus.proto.query.CheckBalanceStatusRequest + (*CheckBalanceStatusResponse)(nil), // 89: milvus.proto.query.CheckBalanceStatusResponse + (*SuspendNodeRequest)(nil), // 90: milvus.proto.query.SuspendNodeRequest + (*ResumeNodeRequest)(nil), // 91: milvus.proto.query.ResumeNodeRequest + (*TransferSegmentRequest)(nil), // 92: milvus.proto.query.TransferSegmentRequest + (*TransferChannelRequest)(nil), // 93: milvus.proto.query.TransferChannelRequest + (*CheckQueryNodeDistributionRequest)(nil), // 94: milvus.proto.query.CheckQueryNodeDistributionRequest + (*UpdateLoadConfigRequest)(nil), // 95: milvus.proto.query.UpdateLoadConfigRequest + (*UpdateSchemaRequest)(nil), // 96: milvus.proto.query.UpdateSchemaRequest + (*RunAnalyzerRequest)(nil), // 97: milvus.proto.query.RunAnalyzerRequest + (*HighlightOptions)(nil), // 98: milvus.proto.query.HighlightOptions + (*HighlightQuery)(nil), // 99: milvus.proto.query.HighlightQuery + (*HighlightTask)(nil), // 100: milvus.proto.query.HighlightTask + (*GetHighlightRequest)(nil), // 101: milvus.proto.query.GetHighlightRequest + (*HighlightFragment)(nil), // 102: milvus.proto.query.HighlightFragment + (*HighlightResult)(nil), // 103: milvus.proto.query.HighlightResult + (*GetHighlightResponse)(nil), // 104: milvus.proto.query.GetHighlightResponse + (*ListLoadedSegmentsRequest)(nil), // 105: milvus.proto.query.ListLoadedSegmentsRequest + (*ListLoadedSegmentsResponse)(nil), // 106: milvus.proto.query.ListLoadedSegmentsResponse + (*DropIndexRequest)(nil), // 107: milvus.proto.query.DropIndexRequest + nil, // 108: milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry + nil, // 109: milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry + nil, // 110: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry + nil, // 111: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry + nil, // 112: milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry + nil, // 113: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry + nil, // 114: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry + nil, // 115: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry + nil, // 116: milvus.proto.query.LeaderView.SegmentDistEntry + nil, // 117: milvus.proto.query.LeaderView.GrowingSegmentsEntry + nil, // 118: milvus.proto.query.LeaderView.PartitionStatsVersionsEntry + nil, // 119: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry + nil, // 120: milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry + nil, // 121: milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry + nil, // 122: milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry + nil, // 123: milvus.proto.query.Replica.ChannelNodeInfosEntry + nil, // 124: milvus.proto.query.SyncAction.PartitionStatsVersionsEntry + nil, // 125: milvus.proto.query.SyncAction.SealedSegmentRowCountEntry + nil, // 126: milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry + nil, // 127: milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry + nil, // 128: milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry + (*commonpb.MsgBase)(nil), // 129: milvus.proto.common.MsgBase + (*commonpb.Status)(nil), // 130: milvus.proto.common.Status + (*schemapb.LongArray)(nil), // 131: milvus.proto.schema.LongArray + (*schemapb.CollectionSchema)(nil), // 132: milvus.proto.schema.CollectionSchema + (commonpb.LoadPriority)(0), // 133: milvus.proto.common.LoadPriority + (*internalpb.GetStatisticsRequest)(nil), // 134: milvus.proto.internal.GetStatisticsRequest + (*indexpb.IndexInfo)(nil), // 135: milvus.proto.index.IndexInfo + (*commonpb.KeyValuePair)(nil), // 136: milvus.proto.common.KeyValuePair + (*datapb.VchannelInfo)(nil), // 137: milvus.proto.data.VchannelInfo + (*datapb.SegmentInfo)(nil), // 138: milvus.proto.data.SegmentInfo + (*datapb.FieldBinlog)(nil), // 139: milvus.proto.data.FieldBinlog + (*msgpb.MsgPosition)(nil), // 140: milvus.proto.msg.MsgPosition + (datapb.SegmentLevel)(0), // 141: milvus.proto.data.SegmentLevel + (*internalpb.SearchRequest)(nil), // 142: milvus.proto.internal.SearchRequest + (*internalpb.RetrieveRequest)(nil), // 143: milvus.proto.internal.RetrieveRequest + (commonpb.SegmentState)(0), // 144: milvus.proto.common.SegmentState + (*rgpb.ResourceGroupConfig)(nil), // 145: milvus.proto.rg.ResourceGroupConfig + (*commonpb.NodeInfo)(nil), // 146: milvus.proto.common.NodeInfo + (*schemapb.IDs)(nil), // 147: milvus.proto.schema.IDs + (*datapb.TextIndexStats)(nil), // 148: milvus.proto.data.TextIndexStats + (*datapb.JsonKeyStats)(nil), // 149: milvus.proto.data.JsonKeyStats + (*internalpb.ShowConfigurationsRequest)(nil), // 150: milvus.proto.internal.ShowConfigurationsRequest + (*milvuspb.GetMetricsRequest)(nil), // 151: milvus.proto.milvus.GetMetricsRequest + (*milvuspb.GetReplicasRequest)(nil), // 152: milvus.proto.milvus.GetReplicasRequest + (*milvuspb.CheckHealthRequest)(nil), // 153: milvus.proto.milvus.CheckHealthRequest + (*milvuspb.CreateResourceGroupRequest)(nil), // 154: milvus.proto.milvus.CreateResourceGroupRequest + (*milvuspb.DropResourceGroupRequest)(nil), // 155: milvus.proto.milvus.DropResourceGroupRequest + (*milvuspb.TransferNodeRequest)(nil), // 156: milvus.proto.milvus.TransferNodeRequest + (*milvuspb.ListResourceGroupsRequest)(nil), // 157: milvus.proto.milvus.ListResourceGroupsRequest + (*milvuspb.GetComponentStatesRequest)(nil), // 158: milvus.proto.milvus.GetComponentStatesRequest + (*internalpb.GetTimeTickChannelRequest)(nil), // 159: milvus.proto.internal.GetTimeTickChannelRequest + (*internalpb.GetStatisticsChannelRequest)(nil), // 160: milvus.proto.internal.GetStatisticsChannelRequest + (*internalpb.ShowConfigurationsResponse)(nil), // 161: milvus.proto.internal.ShowConfigurationsResponse + (*milvuspb.GetMetricsResponse)(nil), // 162: milvus.proto.milvus.GetMetricsResponse + (*milvuspb.GetReplicasResponse)(nil), // 163: milvus.proto.milvus.GetReplicasResponse + (*milvuspb.CheckHealthResponse)(nil), // 164: milvus.proto.milvus.CheckHealthResponse + (*milvuspb.ListResourceGroupsResponse)(nil), // 165: milvus.proto.milvus.ListResourceGroupsResponse + (*milvuspb.ComponentStates)(nil), // 166: milvus.proto.milvus.ComponentStates + (*milvuspb.StringResponse)(nil), // 167: milvus.proto.milvus.StringResponse + (*internalpb.GetStatisticsResponse)(nil), // 168: milvus.proto.internal.GetStatisticsResponse + (*internalpb.SearchResults)(nil), // 169: milvus.proto.internal.SearchResults + (*internalpb.RetrieveResults)(nil), // 170: milvus.proto.internal.RetrieveResults + (*milvuspb.RunAnalyzerResponse)(nil), // 171: milvus.proto.milvus.RunAnalyzerResponse } var file_query_coord_proto_depIdxs = []int32{ - 121, // 0: milvus.proto.query.ShowCollectionsRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 1: milvus.proto.query.ShowCollectionsResponse.status:type_name -> milvus.proto.common.Status - 123, // 2: milvus.proto.query.ShowCollectionsResponse.load_fields:type_name -> milvus.proto.schema.LongArray - 121, // 3: milvus.proto.query.ShowPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 4: milvus.proto.query.ShowPartitionsResponse.status:type_name -> milvus.proto.common.Status - 121, // 5: milvus.proto.query.LoadCollectionRequest.base:type_name -> milvus.proto.common.MsgBase - 124, // 6: milvus.proto.query.LoadCollectionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 100, // 7: milvus.proto.query.LoadCollectionRequest.field_indexID:type_name -> milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry - 125, // 8: milvus.proto.query.LoadCollectionRequest.priority:type_name -> milvus.proto.common.LoadPriority - 121, // 9: milvus.proto.query.ReleaseCollectionRequest.base:type_name -> milvus.proto.common.MsgBase - 126, // 10: milvus.proto.query.GetStatisticsRequest.req:type_name -> milvus.proto.internal.GetStatisticsRequest + 129, // 0: milvus.proto.query.ShowCollectionsRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 1: milvus.proto.query.ShowCollectionsResponse.status:type_name -> milvus.proto.common.Status + 131, // 2: milvus.proto.query.ShowCollectionsResponse.load_fields:type_name -> milvus.proto.schema.LongArray + 129, // 3: milvus.proto.query.ShowPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 4: milvus.proto.query.ShowPartitionsResponse.status:type_name -> milvus.proto.common.Status + 129, // 5: milvus.proto.query.LoadCollectionRequest.base:type_name -> milvus.proto.common.MsgBase + 132, // 6: milvus.proto.query.LoadCollectionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 108, // 7: milvus.proto.query.LoadCollectionRequest.field_indexID:type_name -> milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry + 133, // 8: milvus.proto.query.LoadCollectionRequest.priority:type_name -> milvus.proto.common.LoadPriority + 129, // 9: milvus.proto.query.ReleaseCollectionRequest.base:type_name -> milvus.proto.common.MsgBase + 134, // 10: milvus.proto.query.GetStatisticsRequest.req:type_name -> milvus.proto.internal.GetStatisticsRequest 1, // 11: milvus.proto.query.GetStatisticsRequest.scope:type_name -> milvus.proto.query.DataScope - 121, // 12: milvus.proto.query.LoadPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase - 124, // 13: milvus.proto.query.LoadPartitionsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 101, // 14: milvus.proto.query.LoadPartitionsRequest.field_indexID:type_name -> milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry - 127, // 15: milvus.proto.query.LoadPartitionsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 125, // 16: milvus.proto.query.LoadPartitionsRequest.priority:type_name -> milvus.proto.common.LoadPriority - 121, // 17: milvus.proto.query.ReleasePartitionsRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 18: milvus.proto.query.GetPartitionStatesRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 19: milvus.proto.query.GetPartitionStatesResponse.status:type_name -> milvus.proto.common.Status - 43, // 20: milvus.proto.query.GetPartitionStatesResponse.partition_descriptions:type_name -> milvus.proto.query.PartitionStates - 121, // 21: milvus.proto.query.GetSegmentInfoRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 22: milvus.proto.query.GetSegmentInfoResponse.status:type_name -> milvus.proto.common.Status - 44, // 23: milvus.proto.query.GetSegmentInfoResponse.infos:type_name -> milvus.proto.query.SegmentInfo - 121, // 24: milvus.proto.query.GetShardLeadersRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 25: milvus.proto.query.GetShardLeadersResponse.status:type_name -> milvus.proto.common.Status - 23, // 26: milvus.proto.query.GetShardLeadersResponse.shards:type_name -> milvus.proto.query.ShardLeadersList - 121, // 27: milvus.proto.query.UpdateResourceGroupsRequest.base:type_name -> milvus.proto.common.MsgBase - 102, // 28: milvus.proto.query.UpdateResourceGroupsRequest.resource_groups:type_name -> milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry - 121, // 29: milvus.proto.query.SyncNewCreatedPartitionRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 12: milvus.proto.query.LoadPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase + 132, // 13: milvus.proto.query.LoadPartitionsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 109, // 14: milvus.proto.query.LoadPartitionsRequest.field_indexID:type_name -> milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry + 135, // 15: milvus.proto.query.LoadPartitionsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 133, // 16: milvus.proto.query.LoadPartitionsRequest.priority:type_name -> milvus.proto.common.LoadPriority + 129, // 17: milvus.proto.query.ReleasePartitionsRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 18: milvus.proto.query.GetPartitionStatesRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 19: milvus.proto.query.GetPartitionStatesResponse.status:type_name -> milvus.proto.common.Status + 44, // 20: milvus.proto.query.GetPartitionStatesResponse.partition_descriptions:type_name -> milvus.proto.query.PartitionStates + 129, // 21: milvus.proto.query.GetSegmentInfoRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 22: milvus.proto.query.GetSegmentInfoResponse.status:type_name -> milvus.proto.common.Status + 45, // 23: milvus.proto.query.GetSegmentInfoResponse.infos:type_name -> milvus.proto.query.SegmentInfo + 129, // 24: milvus.proto.query.GetShardLeadersRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 25: milvus.proto.query.GetShardLeadersResponse.status:type_name -> milvus.proto.common.Status + 24, // 26: milvus.proto.query.GetShardLeadersResponse.shards:type_name -> milvus.proto.query.ShardLeadersList + 129, // 27: milvus.proto.query.UpdateResourceGroupsRequest.base:type_name -> milvus.proto.common.MsgBase + 110, // 28: milvus.proto.query.UpdateResourceGroupsRequest.resource_groups:type_name -> milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry + 129, // 29: milvus.proto.query.SyncNewCreatedPartitionRequest.base:type_name -> milvus.proto.common.MsgBase 4, // 30: milvus.proto.query.LoadMetaInfo.load_type:type_name -> milvus.proto.query.LoadType - 128, // 31: milvus.proto.query.LoadMetaInfo.db_properties:type_name -> milvus.proto.common.KeyValuePair - 121, // 32: milvus.proto.query.WatchDmChannelsRequest.base:type_name -> milvus.proto.common.MsgBase - 129, // 33: milvus.proto.query.WatchDmChannelsRequest.infos:type_name -> milvus.proto.data.VchannelInfo - 124, // 34: milvus.proto.query.WatchDmChannelsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 130, // 35: milvus.proto.query.WatchDmChannelsRequest.exclude_infos:type_name -> milvus.proto.data.SegmentInfo - 25, // 36: milvus.proto.query.WatchDmChannelsRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo - 103, // 37: milvus.proto.query.WatchDmChannelsRequest.segment_infos:type_name -> milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry - 127, // 38: milvus.proto.query.WatchDmChannelsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 104, // 39: milvus.proto.query.WatchDmChannelsRequest.sealed_segment_row_count:type_name -> milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry - 121, // 40: milvus.proto.query.UnsubDmChannelRequest.base:type_name -> milvus.proto.common.MsgBase - 131, // 41: milvus.proto.query.SegmentLoadInfo.binlog_paths:type_name -> milvus.proto.data.FieldBinlog - 131, // 42: milvus.proto.query.SegmentLoadInfo.statslogs:type_name -> milvus.proto.data.FieldBinlog - 131, // 43: milvus.proto.query.SegmentLoadInfo.deltalogs:type_name -> milvus.proto.data.FieldBinlog - 29, // 44: milvus.proto.query.SegmentLoadInfo.index_infos:type_name -> milvus.proto.query.FieldIndexInfo - 132, // 45: milvus.proto.query.SegmentLoadInfo.start_position:type_name -> milvus.proto.msg.MsgPosition - 132, // 46: milvus.proto.query.SegmentLoadInfo.delta_position:type_name -> milvus.proto.msg.MsgPosition - 133, // 47: milvus.proto.query.SegmentLoadInfo.level:type_name -> milvus.proto.data.SegmentLevel - 105, // 48: milvus.proto.query.SegmentLoadInfo.textStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry - 131, // 49: milvus.proto.query.SegmentLoadInfo.bm25logs:type_name -> milvus.proto.data.FieldBinlog - 106, // 50: milvus.proto.query.SegmentLoadInfo.jsonKeyStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry - 125, // 51: milvus.proto.query.SegmentLoadInfo.priority:type_name -> milvus.proto.common.LoadPriority - 128, // 52: milvus.proto.query.FieldIndexInfo.index_params:type_name -> milvus.proto.common.KeyValuePair - 121, // 53: milvus.proto.query.LoadSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 28, // 54: milvus.proto.query.LoadSegmentsRequest.infos:type_name -> milvus.proto.query.SegmentLoadInfo - 124, // 55: milvus.proto.query.LoadSegmentsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 25, // 56: milvus.proto.query.LoadSegmentsRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo - 132, // 57: milvus.proto.query.LoadSegmentsRequest.delta_positions:type_name -> milvus.proto.msg.MsgPosition + 136, // 31: milvus.proto.query.LoadMetaInfo.db_properties:type_name -> milvus.proto.common.KeyValuePair + 129, // 32: milvus.proto.query.WatchDmChannelsRequest.base:type_name -> milvus.proto.common.MsgBase + 137, // 33: milvus.proto.query.WatchDmChannelsRequest.infos:type_name -> milvus.proto.data.VchannelInfo + 132, // 34: milvus.proto.query.WatchDmChannelsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 138, // 35: milvus.proto.query.WatchDmChannelsRequest.exclude_infos:type_name -> milvus.proto.data.SegmentInfo + 26, // 36: milvus.proto.query.WatchDmChannelsRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo + 111, // 37: milvus.proto.query.WatchDmChannelsRequest.segment_infos:type_name -> milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry + 135, // 38: milvus.proto.query.WatchDmChannelsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 112, // 39: milvus.proto.query.WatchDmChannelsRequest.sealed_segment_row_count:type_name -> milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry + 129, // 40: milvus.proto.query.UnsubDmChannelRequest.base:type_name -> milvus.proto.common.MsgBase + 139, // 41: milvus.proto.query.SegmentLoadInfo.binlog_paths:type_name -> milvus.proto.data.FieldBinlog + 139, // 42: milvus.proto.query.SegmentLoadInfo.statslogs:type_name -> milvus.proto.data.FieldBinlog + 139, // 43: milvus.proto.query.SegmentLoadInfo.deltalogs:type_name -> milvus.proto.data.FieldBinlog + 30, // 44: milvus.proto.query.SegmentLoadInfo.index_infos:type_name -> milvus.proto.query.FieldIndexInfo + 140, // 45: milvus.proto.query.SegmentLoadInfo.start_position:type_name -> milvus.proto.msg.MsgPosition + 140, // 46: milvus.proto.query.SegmentLoadInfo.delta_position:type_name -> milvus.proto.msg.MsgPosition + 141, // 47: milvus.proto.query.SegmentLoadInfo.level:type_name -> milvus.proto.data.SegmentLevel + 113, // 48: milvus.proto.query.SegmentLoadInfo.textStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry + 139, // 49: milvus.proto.query.SegmentLoadInfo.bm25logs:type_name -> milvus.proto.data.FieldBinlog + 114, // 50: milvus.proto.query.SegmentLoadInfo.jsonKeyStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry + 133, // 51: milvus.proto.query.SegmentLoadInfo.priority:type_name -> milvus.proto.common.LoadPriority + 136, // 52: milvus.proto.query.FieldIndexInfo.index_params:type_name -> milvus.proto.common.KeyValuePair + 129, // 53: milvus.proto.query.LoadSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 29, // 54: milvus.proto.query.LoadSegmentsRequest.infos:type_name -> milvus.proto.query.SegmentLoadInfo + 132, // 55: milvus.proto.query.LoadSegmentsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 26, // 56: milvus.proto.query.LoadSegmentsRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo + 140, // 57: milvus.proto.query.LoadSegmentsRequest.delta_positions:type_name -> milvus.proto.msg.MsgPosition 0, // 58: milvus.proto.query.LoadSegmentsRequest.load_scope:type_name -> milvus.proto.query.LoadScope - 127, // 59: milvus.proto.query.LoadSegmentsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 121, // 60: milvus.proto.query.ReleaseSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 135, // 59: milvus.proto.query.LoadSegmentsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 129, // 60: milvus.proto.query.ReleaseSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase 1, // 61: milvus.proto.query.ReleaseSegmentsRequest.scope:type_name -> milvus.proto.query.DataScope - 132, // 62: milvus.proto.query.ReleaseSegmentsRequest.checkpoint:type_name -> milvus.proto.msg.MsgPosition - 134, // 63: milvus.proto.query.SearchRequest.req:type_name -> milvus.proto.internal.SearchRequest + 140, // 62: milvus.proto.query.ReleaseSegmentsRequest.checkpoint:type_name -> milvus.proto.msg.MsgPosition + 142, // 63: milvus.proto.query.SearchRequest.req:type_name -> milvus.proto.internal.SearchRequest 1, // 64: milvus.proto.query.SearchRequest.scope:type_name -> milvus.proto.query.DataScope - 135, // 65: milvus.proto.query.QueryRequest.req:type_name -> milvus.proto.internal.RetrieveRequest + 143, // 65: milvus.proto.query.QueryRequest.req:type_name -> milvus.proto.internal.RetrieveRequest 1, // 66: milvus.proto.query.QueryRequest.scope:type_name -> milvus.proto.query.DataScope - 121, // 67: milvus.proto.query.SyncReplicaSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 36, // 68: milvus.proto.query.SyncReplicaSegmentsRequest.replica_segments:type_name -> milvus.proto.query.ReplicaSegmentsInfo - 121, // 69: milvus.proto.query.GetLoadInfoRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 70: milvus.proto.query.GetLoadInfoResponse.status:type_name -> milvus.proto.common.Status - 124, // 71: milvus.proto.query.GetLoadInfoResponse.schema:type_name -> milvus.proto.schema.CollectionSchema + 129, // 67: milvus.proto.query.SyncReplicaSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 37, // 68: milvus.proto.query.SyncReplicaSegmentsRequest.replica_segments:type_name -> milvus.proto.query.ReplicaSegmentsInfo + 129, // 69: milvus.proto.query.GetLoadInfoRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 70: milvus.proto.query.GetLoadInfoResponse.status:type_name -> milvus.proto.common.Status + 132, // 71: milvus.proto.query.GetLoadInfoResponse.schema:type_name -> milvus.proto.schema.CollectionSchema 4, // 72: milvus.proto.query.GetLoadInfoResponse.load_type:type_name -> milvus.proto.query.LoadType - 121, // 73: milvus.proto.query.HandoffSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 44, // 74: milvus.proto.query.HandoffSegmentsRequest.segmentInfos:type_name -> milvus.proto.query.SegmentInfo - 121, // 75: milvus.proto.query.LoadBalanceRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 73: milvus.proto.query.HandoffSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 45, // 74: milvus.proto.query.HandoffSegmentsRequest.segmentInfos:type_name -> milvus.proto.query.SegmentInfo + 129, // 75: milvus.proto.query.LoadBalanceRequest.base:type_name -> milvus.proto.common.MsgBase 3, // 76: milvus.proto.query.LoadBalanceRequest.balance_reason:type_name -> milvus.proto.query.TriggerCondition - 44, // 77: milvus.proto.query.QueryChannelInfo.global_sealed_segments:type_name -> milvus.proto.query.SegmentInfo - 132, // 78: milvus.proto.query.QueryChannelInfo.seek_position:type_name -> milvus.proto.msg.MsgPosition + 45, // 77: milvus.proto.query.QueryChannelInfo.global_sealed_segments:type_name -> milvus.proto.query.SegmentInfo + 140, // 78: milvus.proto.query.QueryChannelInfo.seek_position:type_name -> milvus.proto.msg.MsgPosition 2, // 79: milvus.proto.query.PartitionStates.state:type_name -> milvus.proto.query.PartitionState - 136, // 80: milvus.proto.query.SegmentInfo.segment_state:type_name -> milvus.proto.common.SegmentState - 29, // 81: milvus.proto.query.SegmentInfo.index_infos:type_name -> milvus.proto.query.FieldIndexInfo - 133, // 82: milvus.proto.query.SegmentInfo.level:type_name -> milvus.proto.data.SegmentLevel - 43, // 83: milvus.proto.query.CollectionInfo.partition_states:type_name -> milvus.proto.query.PartitionStates + 144, // 80: milvus.proto.query.SegmentInfo.segment_state:type_name -> milvus.proto.common.SegmentState + 30, // 81: milvus.proto.query.SegmentInfo.index_infos:type_name -> milvus.proto.query.FieldIndexInfo + 141, // 82: milvus.proto.query.SegmentInfo.level:type_name -> milvus.proto.data.SegmentLevel + 44, // 83: milvus.proto.query.CollectionInfo.partition_states:type_name -> milvus.proto.query.PartitionStates 4, // 84: milvus.proto.query.CollectionInfo.load_type:type_name -> milvus.proto.query.LoadType - 124, // 85: milvus.proto.query.CollectionInfo.schema:type_name -> milvus.proto.schema.CollectionSchema - 46, // 86: milvus.proto.query.UnsubscribeChannelInfo.collection_channels:type_name -> milvus.proto.query.UnsubscribeChannels - 44, // 87: milvus.proto.query.SegmentChangeInfo.online_segments:type_name -> milvus.proto.query.SegmentInfo - 44, // 88: milvus.proto.query.SegmentChangeInfo.offline_segments:type_name -> milvus.proto.query.SegmentInfo - 121, // 89: milvus.proto.query.SealedSegmentsChangeInfo.base:type_name -> milvus.proto.common.MsgBase - 48, // 90: milvus.proto.query.SealedSegmentsChangeInfo.infos:type_name -> milvus.proto.query.SegmentChangeInfo - 121, // 91: milvus.proto.query.GetDataDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 107, // 92: milvus.proto.query.GetDataDistributionRequest.checkpoints:type_name -> milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry - 122, // 93: milvus.proto.query.GetDataDistributionResponse.status:type_name -> milvus.proto.common.Status - 55, // 94: milvus.proto.query.GetDataDistributionResponse.segments:type_name -> milvus.proto.query.SegmentVersionInfo - 56, // 95: milvus.proto.query.GetDataDistributionResponse.channels:type_name -> milvus.proto.query.ChannelVersionInfo - 52, // 96: milvus.proto.query.GetDataDistributionResponse.leader_views:type_name -> milvus.proto.query.LeaderView - 108, // 97: milvus.proto.query.LeaderView.segment_dist:type_name -> milvus.proto.query.LeaderView.SegmentDistEntry - 109, // 98: milvus.proto.query.LeaderView.growing_segments:type_name -> milvus.proto.query.LeaderView.GrowingSegmentsEntry - 110, // 99: milvus.proto.query.LeaderView.partition_stats_versions:type_name -> milvus.proto.query.LeaderView.PartitionStatsVersionsEntry - 53, // 100: milvus.proto.query.LeaderView.status:type_name -> milvus.proto.query.LeaderViewStatus - 111, // 101: milvus.proto.query.SegmentVersionInfo.index_info:type_name -> milvus.proto.query.SegmentVersionInfo.IndexInfoEntry - 133, // 102: milvus.proto.query.SegmentVersionInfo.level:type_name -> milvus.proto.data.SegmentLevel - 112, // 103: milvus.proto.query.SegmentVersionInfo.json_stats_info:type_name -> milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry + 132, // 85: milvus.proto.query.CollectionInfo.schema:type_name -> milvus.proto.schema.CollectionSchema + 47, // 86: milvus.proto.query.UnsubscribeChannelInfo.collection_channels:type_name -> milvus.proto.query.UnsubscribeChannels + 45, // 87: milvus.proto.query.SegmentChangeInfo.online_segments:type_name -> milvus.proto.query.SegmentInfo + 45, // 88: milvus.proto.query.SegmentChangeInfo.offline_segments:type_name -> milvus.proto.query.SegmentInfo + 129, // 89: milvus.proto.query.SealedSegmentsChangeInfo.base:type_name -> milvus.proto.common.MsgBase + 49, // 90: milvus.proto.query.SealedSegmentsChangeInfo.infos:type_name -> milvus.proto.query.SegmentChangeInfo + 129, // 91: milvus.proto.query.GetDataDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 115, // 92: milvus.proto.query.GetDataDistributionRequest.checkpoints:type_name -> milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry + 130, // 93: milvus.proto.query.GetDataDistributionResponse.status:type_name -> milvus.proto.common.Status + 56, // 94: milvus.proto.query.GetDataDistributionResponse.segments:type_name -> milvus.proto.query.SegmentVersionInfo + 57, // 95: milvus.proto.query.GetDataDistributionResponse.channels:type_name -> milvus.proto.query.ChannelVersionInfo + 53, // 96: milvus.proto.query.GetDataDistributionResponse.leader_views:type_name -> milvus.proto.query.LeaderView + 116, // 97: milvus.proto.query.LeaderView.segment_dist:type_name -> milvus.proto.query.LeaderView.SegmentDistEntry + 117, // 98: milvus.proto.query.LeaderView.growing_segments:type_name -> milvus.proto.query.LeaderView.GrowingSegmentsEntry + 118, // 99: milvus.proto.query.LeaderView.partition_stats_versions:type_name -> milvus.proto.query.LeaderView.PartitionStatsVersionsEntry + 54, // 100: milvus.proto.query.LeaderView.status:type_name -> milvus.proto.query.LeaderViewStatus + 119, // 101: milvus.proto.query.SegmentVersionInfo.index_info:type_name -> milvus.proto.query.SegmentVersionInfo.IndexInfoEntry + 141, // 102: milvus.proto.query.SegmentVersionInfo.level:type_name -> milvus.proto.data.SegmentLevel + 120, // 103: milvus.proto.query.SegmentVersionInfo.json_stats_info:type_name -> milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry 5, // 104: milvus.proto.query.CollectionLoadInfo.status:type_name -> milvus.proto.query.LoadStatus - 113, // 105: milvus.proto.query.CollectionLoadInfo.field_indexID:type_name -> milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry + 121, // 105: milvus.proto.query.CollectionLoadInfo.field_indexID:type_name -> milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry 4, // 106: milvus.proto.query.CollectionLoadInfo.load_type:type_name -> milvus.proto.query.LoadType 5, // 107: milvus.proto.query.PartitionLoadInfo.status:type_name -> milvus.proto.query.LoadStatus - 114, // 108: milvus.proto.query.PartitionLoadInfo.field_indexID:type_name -> milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry - 115, // 109: milvus.proto.query.Replica.channel_node_infos:type_name -> milvus.proto.query.Replica.ChannelNodeInfosEntry + 122, // 108: milvus.proto.query.PartitionLoadInfo.field_indexID:type_name -> milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry + 123, // 109: milvus.proto.query.Replica.channel_node_infos:type_name -> milvus.proto.query.Replica.ChannelNodeInfosEntry 6, // 110: milvus.proto.query.SyncAction.type:type_name -> milvus.proto.query.SyncType - 28, // 111: milvus.proto.query.SyncAction.info:type_name -> milvus.proto.query.SegmentLoadInfo - 132, // 112: milvus.proto.query.SyncAction.checkpoint:type_name -> milvus.proto.msg.MsgPosition - 116, // 113: milvus.proto.query.SyncAction.partition_stats_versions:type_name -> milvus.proto.query.SyncAction.PartitionStatsVersionsEntry - 132, // 114: milvus.proto.query.SyncAction.deleteCP:type_name -> milvus.proto.msg.MsgPosition - 117, // 115: milvus.proto.query.SyncAction.sealed_segment_row_count:type_name -> milvus.proto.query.SyncAction.SealedSegmentRowCountEntry - 121, // 116: milvus.proto.query.SyncDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 61, // 117: milvus.proto.query.SyncDistributionRequest.actions:type_name -> milvus.proto.query.SyncAction - 124, // 118: milvus.proto.query.SyncDistributionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 25, // 119: milvus.proto.query.SyncDistributionRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo - 127, // 120: milvus.proto.query.SyncDistributionRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 137, // 121: milvus.proto.query.ResourceGroup.config:type_name -> milvus.proto.rg.ResourceGroupConfig - 121, // 122: milvus.proto.query.TransferReplicaRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 123: milvus.proto.query.DescribeResourceGroupRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 124: milvus.proto.query.DescribeResourceGroupResponse.status:type_name -> milvus.proto.common.Status - 67, // 125: milvus.proto.query.DescribeResourceGroupResponse.resource_group:type_name -> milvus.proto.query.ResourceGroupInfo - 118, // 126: milvus.proto.query.ResourceGroupInfo.num_loaded_replica:type_name -> milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry - 119, // 127: milvus.proto.query.ResourceGroupInfo.num_outgoing_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry - 120, // 128: milvus.proto.query.ResourceGroupInfo.num_incoming_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry - 137, // 129: milvus.proto.query.ResourceGroupInfo.config:type_name -> milvus.proto.rg.ResourceGroupConfig - 138, // 130: milvus.proto.query.ResourceGroupInfo.nodes:type_name -> milvus.proto.common.NodeInfo - 121, // 131: milvus.proto.query.DeleteRequest.base:type_name -> milvus.proto.common.MsgBase - 139, // 132: milvus.proto.query.DeleteRequest.primary_keys:type_name -> milvus.proto.schema.IDs + 29, // 111: milvus.proto.query.SyncAction.info:type_name -> milvus.proto.query.SegmentLoadInfo + 140, // 112: milvus.proto.query.SyncAction.checkpoint:type_name -> milvus.proto.msg.MsgPosition + 124, // 113: milvus.proto.query.SyncAction.partition_stats_versions:type_name -> milvus.proto.query.SyncAction.PartitionStatsVersionsEntry + 140, // 114: milvus.proto.query.SyncAction.deleteCP:type_name -> milvus.proto.msg.MsgPosition + 125, // 115: milvus.proto.query.SyncAction.sealed_segment_row_count:type_name -> milvus.proto.query.SyncAction.SealedSegmentRowCountEntry + 129, // 116: milvus.proto.query.SyncDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 62, // 117: milvus.proto.query.SyncDistributionRequest.actions:type_name -> milvus.proto.query.SyncAction + 132, // 118: milvus.proto.query.SyncDistributionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 26, // 119: milvus.proto.query.SyncDistributionRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo + 135, // 120: milvus.proto.query.SyncDistributionRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 145, // 121: milvus.proto.query.ResourceGroup.config:type_name -> milvus.proto.rg.ResourceGroupConfig + 129, // 122: milvus.proto.query.TransferReplicaRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 123: milvus.proto.query.DescribeResourceGroupRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 124: milvus.proto.query.DescribeResourceGroupResponse.status:type_name -> milvus.proto.common.Status + 68, // 125: milvus.proto.query.DescribeResourceGroupResponse.resource_group:type_name -> milvus.proto.query.ResourceGroupInfo + 126, // 126: milvus.proto.query.ResourceGroupInfo.num_loaded_replica:type_name -> milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry + 127, // 127: milvus.proto.query.ResourceGroupInfo.num_outgoing_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry + 128, // 128: milvus.proto.query.ResourceGroupInfo.num_incoming_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry + 145, // 129: milvus.proto.query.ResourceGroupInfo.config:type_name -> milvus.proto.rg.ResourceGroupConfig + 146, // 130: milvus.proto.query.ResourceGroupInfo.nodes:type_name -> milvus.proto.common.NodeInfo + 129, // 131: milvus.proto.query.DeleteRequest.base:type_name -> milvus.proto.common.MsgBase + 147, // 132: milvus.proto.query.DeleteRequest.primary_keys:type_name -> milvus.proto.schema.IDs 1, // 133: milvus.proto.query.DeleteRequest.scope:type_name -> milvus.proto.query.DataScope - 121, // 134: milvus.proto.query.DeleteBatchRequest.base:type_name -> milvus.proto.common.MsgBase - 139, // 135: milvus.proto.query.DeleteBatchRequest.primary_keys:type_name -> milvus.proto.schema.IDs + 129, // 134: milvus.proto.query.DeleteBatchRequest.base:type_name -> milvus.proto.common.MsgBase + 147, // 135: milvus.proto.query.DeleteBatchRequest.primary_keys:type_name -> milvus.proto.schema.IDs 1, // 136: milvus.proto.query.DeleteBatchRequest.scope:type_name -> milvus.proto.query.DataScope - 122, // 137: milvus.proto.query.DeleteBatchResponse.status:type_name -> milvus.proto.common.Status - 121, // 138: milvus.proto.query.ActivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 139: milvus.proto.query.DeactivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 140: milvus.proto.query.ListCheckersRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 141: milvus.proto.query.ListCheckersResponse.status:type_name -> milvus.proto.common.Status - 75, // 142: milvus.proto.query.ListCheckersResponse.checkerInfos:type_name -> milvus.proto.query.CheckerInfo - 133, // 143: milvus.proto.query.SegmentTarget.level:type_name -> milvus.proto.data.SegmentLevel - 76, // 144: milvus.proto.query.PartitionTarget.segments:type_name -> milvus.proto.query.SegmentTarget - 77, // 145: milvus.proto.query.ChannelTarget.partition_targets:type_name -> milvus.proto.query.PartitionTarget - 132, // 146: milvus.proto.query.ChannelTarget.seek_position:type_name -> milvus.proto.msg.MsgPosition - 132, // 147: milvus.proto.query.ChannelTarget.delete_checkpoint:type_name -> milvus.proto.msg.MsgPosition - 78, // 148: milvus.proto.query.CollectionTarget.Channel_targets:type_name -> milvus.proto.query.ChannelTarget - 121, // 149: milvus.proto.query.ListQueryNodeRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 150: milvus.proto.query.ListQueryNodeResponse.status:type_name -> milvus.proto.common.Status - 80, // 151: milvus.proto.query.ListQueryNodeResponse.nodeInfos:type_name -> milvus.proto.query.NodeInfo - 121, // 152: milvus.proto.query.GetQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 153: milvus.proto.query.GetQueryNodeDistributionResponse.status:type_name -> milvus.proto.common.Status - 121, // 154: milvus.proto.query.SuspendBalanceRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 155: milvus.proto.query.ResumeBalanceRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 156: milvus.proto.query.CheckBalanceStatusRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 157: milvus.proto.query.CheckBalanceStatusResponse.status:type_name -> milvus.proto.common.Status - 121, // 158: milvus.proto.query.SuspendNodeRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 159: milvus.proto.query.ResumeNodeRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 160: milvus.proto.query.TransferSegmentRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 161: milvus.proto.query.TransferChannelRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 162: milvus.proto.query.CheckQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 163: milvus.proto.query.UpdateLoadConfigRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 164: milvus.proto.query.UpdateSchemaRequest.base:type_name -> milvus.proto.common.MsgBase - 124, // 165: milvus.proto.query.UpdateSchemaRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 121, // 166: milvus.proto.query.RunAnalyzerRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 167: milvus.proto.query.ListLoadedSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 122, // 168: milvus.proto.query.ListLoadedSegmentsResponse.status:type_name -> milvus.proto.common.Status - 121, // 169: milvus.proto.query.DropIndexRequest.base:type_name -> milvus.proto.common.MsgBase - 137, // 170: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry.value:type_name -> milvus.proto.rg.ResourceGroupConfig - 130, // 171: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry.value:type_name -> milvus.proto.data.SegmentInfo - 140, // 172: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry.value:type_name -> milvus.proto.data.TextIndexStats - 141, // 173: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry.value:type_name -> milvus.proto.data.JsonKeyStats - 132, // 174: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry.value:type_name -> milvus.proto.msg.MsgPosition - 54, // 175: milvus.proto.query.LeaderView.SegmentDistEntry.value:type_name -> milvus.proto.query.SegmentDist - 132, // 176: milvus.proto.query.LeaderView.GrowingSegmentsEntry.value:type_name -> milvus.proto.msg.MsgPosition - 29, // 177: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry.value:type_name -> milvus.proto.query.FieldIndexInfo - 30, // 178: milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry.value:type_name -> milvus.proto.query.JsonStatsInfo - 59, // 179: milvus.proto.query.Replica.ChannelNodeInfosEntry.value:type_name -> milvus.proto.query.ChannelNodeInfo - 7, // 180: milvus.proto.query.QueryCoord.ShowLoadCollections:input_type -> milvus.proto.query.ShowCollectionsRequest - 9, // 181: milvus.proto.query.QueryCoord.ShowLoadPartitions:input_type -> milvus.proto.query.ShowPartitionsRequest - 14, // 182: milvus.proto.query.QueryCoord.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest - 15, // 183: milvus.proto.query.QueryCoord.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest - 11, // 184: milvus.proto.query.QueryCoord.LoadCollection:input_type -> milvus.proto.query.LoadCollectionRequest - 12, // 185: milvus.proto.query.QueryCoord.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest - 24, // 186: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:input_type -> milvus.proto.query.SyncNewCreatedPartitionRequest - 16, // 187: milvus.proto.query.QueryCoord.GetPartitionStates:input_type -> milvus.proto.query.GetPartitionStatesRequest - 18, // 188: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest - 40, // 189: milvus.proto.query.QueryCoord.LoadBalance:input_type -> milvus.proto.query.LoadBalanceRequest - 142, // 190: milvus.proto.query.QueryCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest - 143, // 191: milvus.proto.query.QueryCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest - 144, // 192: milvus.proto.query.QueryCoord.GetReplicas:input_type -> milvus.proto.milvus.GetReplicasRequest - 20, // 193: milvus.proto.query.QueryCoord.GetShardLeaders:input_type -> milvus.proto.query.GetShardLeadersRequest - 145, // 194: milvus.proto.query.QueryCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest - 146, // 195: milvus.proto.query.QueryCoord.CreateResourceGroup:input_type -> milvus.proto.milvus.CreateResourceGroupRequest - 22, // 196: milvus.proto.query.QueryCoord.UpdateResourceGroups:input_type -> milvus.proto.query.UpdateResourceGroupsRequest - 147, // 197: milvus.proto.query.QueryCoord.DropResourceGroup:input_type -> milvus.proto.milvus.DropResourceGroupRequest - 148, // 198: milvus.proto.query.QueryCoord.TransferNode:input_type -> milvus.proto.milvus.TransferNodeRequest - 64, // 199: milvus.proto.query.QueryCoord.TransferReplica:input_type -> milvus.proto.query.TransferReplicaRequest - 149, // 200: milvus.proto.query.QueryCoord.ListResourceGroups:input_type -> milvus.proto.milvus.ListResourceGroupsRequest - 65, // 201: milvus.proto.query.QueryCoord.DescribeResourceGroup:input_type -> milvus.proto.query.DescribeResourceGroupRequest - 97, // 202: milvus.proto.query.QueryCoord.ListLoadedSegments:input_type -> milvus.proto.query.ListLoadedSegmentsRequest - 73, // 203: milvus.proto.query.QueryCoord.ListCheckers:input_type -> milvus.proto.query.ListCheckersRequest - 71, // 204: milvus.proto.query.QueryCoord.ActivateChecker:input_type -> milvus.proto.query.ActivateCheckerRequest - 72, // 205: milvus.proto.query.QueryCoord.DeactivateChecker:input_type -> milvus.proto.query.DeactivateCheckerRequest - 81, // 206: milvus.proto.query.QueryCoord.ListQueryNode:input_type -> milvus.proto.query.ListQueryNodeRequest - 83, // 207: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:input_type -> milvus.proto.query.GetQueryNodeDistributionRequest - 85, // 208: milvus.proto.query.QueryCoord.SuspendBalance:input_type -> milvus.proto.query.SuspendBalanceRequest - 86, // 209: milvus.proto.query.QueryCoord.ResumeBalance:input_type -> milvus.proto.query.ResumeBalanceRequest - 87, // 210: milvus.proto.query.QueryCoord.CheckBalanceStatus:input_type -> milvus.proto.query.CheckBalanceStatusRequest - 89, // 211: milvus.proto.query.QueryCoord.SuspendNode:input_type -> milvus.proto.query.SuspendNodeRequest - 90, // 212: milvus.proto.query.QueryCoord.ResumeNode:input_type -> milvus.proto.query.ResumeNodeRequest - 91, // 213: milvus.proto.query.QueryCoord.TransferSegment:input_type -> milvus.proto.query.TransferSegmentRequest - 92, // 214: milvus.proto.query.QueryCoord.TransferChannel:input_type -> milvus.proto.query.TransferChannelRequest - 93, // 215: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:input_type -> milvus.proto.query.CheckQueryNodeDistributionRequest - 94, // 216: milvus.proto.query.QueryCoord.UpdateLoadConfig:input_type -> milvus.proto.query.UpdateLoadConfigRequest - 150, // 217: milvus.proto.query.QueryNode.GetComponentStates:input_type -> milvus.proto.milvus.GetComponentStatesRequest - 151, // 218: milvus.proto.query.QueryNode.GetTimeTickChannel:input_type -> milvus.proto.internal.GetTimeTickChannelRequest - 152, // 219: milvus.proto.query.QueryNode.GetStatisticsChannel:input_type -> milvus.proto.internal.GetStatisticsChannelRequest - 26, // 220: milvus.proto.query.QueryNode.WatchDmChannels:input_type -> milvus.proto.query.WatchDmChannelsRequest - 27, // 221: milvus.proto.query.QueryNode.UnsubDmChannel:input_type -> milvus.proto.query.UnsubDmChannelRequest - 31, // 222: milvus.proto.query.QueryNode.LoadSegments:input_type -> milvus.proto.query.LoadSegmentsRequest - 12, // 223: milvus.proto.query.QueryNode.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest - 14, // 224: milvus.proto.query.QueryNode.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest - 15, // 225: milvus.proto.query.QueryNode.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest - 32, // 226: milvus.proto.query.QueryNode.ReleaseSegments:input_type -> milvus.proto.query.ReleaseSegmentsRequest - 18, // 227: milvus.proto.query.QueryNode.GetSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest - 35, // 228: milvus.proto.query.QueryNode.SyncReplicaSegments:input_type -> milvus.proto.query.SyncReplicaSegmentsRequest - 13, // 229: milvus.proto.query.QueryNode.GetStatistics:input_type -> milvus.proto.query.GetStatisticsRequest - 33, // 230: milvus.proto.query.QueryNode.Search:input_type -> milvus.proto.query.SearchRequest - 33, // 231: milvus.proto.query.QueryNode.SearchSegments:input_type -> milvus.proto.query.SearchRequest - 34, // 232: milvus.proto.query.QueryNode.Query:input_type -> milvus.proto.query.QueryRequest - 34, // 233: milvus.proto.query.QueryNode.QueryStream:input_type -> milvus.proto.query.QueryRequest - 34, // 234: milvus.proto.query.QueryNode.QuerySegments:input_type -> milvus.proto.query.QueryRequest - 34, // 235: milvus.proto.query.QueryNode.QueryStreamSegments:input_type -> milvus.proto.query.QueryRequest - 142, // 236: milvus.proto.query.QueryNode.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest - 143, // 237: milvus.proto.query.QueryNode.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest - 50, // 238: milvus.proto.query.QueryNode.GetDataDistribution:input_type -> milvus.proto.query.GetDataDistributionRequest - 62, // 239: milvus.proto.query.QueryNode.SyncDistribution:input_type -> milvus.proto.query.SyncDistributionRequest - 68, // 240: milvus.proto.query.QueryNode.Delete:input_type -> milvus.proto.query.DeleteRequest - 69, // 241: milvus.proto.query.QueryNode.DeleteBatch:input_type -> milvus.proto.query.DeleteBatchRequest - 95, // 242: milvus.proto.query.QueryNode.UpdateSchema:input_type -> milvus.proto.query.UpdateSchemaRequest - 96, // 243: milvus.proto.query.QueryNode.RunAnalyzer:input_type -> milvus.proto.query.RunAnalyzerRequest - 99, // 244: milvus.proto.query.QueryNode.DropIndex:input_type -> milvus.proto.query.DropIndexRequest - 8, // 245: milvus.proto.query.QueryCoord.ShowLoadCollections:output_type -> milvus.proto.query.ShowCollectionsResponse - 10, // 246: milvus.proto.query.QueryCoord.ShowLoadPartitions:output_type -> milvus.proto.query.ShowPartitionsResponse - 122, // 247: milvus.proto.query.QueryCoord.LoadPartitions:output_type -> milvus.proto.common.Status - 122, // 248: milvus.proto.query.QueryCoord.ReleasePartitions:output_type -> milvus.proto.common.Status - 122, // 249: milvus.proto.query.QueryCoord.LoadCollection:output_type -> milvus.proto.common.Status - 122, // 250: milvus.proto.query.QueryCoord.ReleaseCollection:output_type -> milvus.proto.common.Status - 122, // 251: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:output_type -> milvus.proto.common.Status - 17, // 252: milvus.proto.query.QueryCoord.GetPartitionStates:output_type -> milvus.proto.query.GetPartitionStatesResponse - 19, // 253: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse - 122, // 254: milvus.proto.query.QueryCoord.LoadBalance:output_type -> milvus.proto.common.Status - 153, // 255: milvus.proto.query.QueryCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse - 154, // 256: milvus.proto.query.QueryCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse - 155, // 257: milvus.proto.query.QueryCoord.GetReplicas:output_type -> milvus.proto.milvus.GetReplicasResponse - 21, // 258: milvus.proto.query.QueryCoord.GetShardLeaders:output_type -> milvus.proto.query.GetShardLeadersResponse - 156, // 259: milvus.proto.query.QueryCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse - 122, // 260: milvus.proto.query.QueryCoord.CreateResourceGroup:output_type -> milvus.proto.common.Status - 122, // 261: milvus.proto.query.QueryCoord.UpdateResourceGroups:output_type -> milvus.proto.common.Status - 122, // 262: milvus.proto.query.QueryCoord.DropResourceGroup:output_type -> milvus.proto.common.Status - 122, // 263: milvus.proto.query.QueryCoord.TransferNode:output_type -> milvus.proto.common.Status - 122, // 264: milvus.proto.query.QueryCoord.TransferReplica:output_type -> milvus.proto.common.Status - 157, // 265: milvus.proto.query.QueryCoord.ListResourceGroups:output_type -> milvus.proto.milvus.ListResourceGroupsResponse - 66, // 266: milvus.proto.query.QueryCoord.DescribeResourceGroup:output_type -> milvus.proto.query.DescribeResourceGroupResponse - 98, // 267: milvus.proto.query.QueryCoord.ListLoadedSegments:output_type -> milvus.proto.query.ListLoadedSegmentsResponse - 74, // 268: milvus.proto.query.QueryCoord.ListCheckers:output_type -> milvus.proto.query.ListCheckersResponse - 122, // 269: milvus.proto.query.QueryCoord.ActivateChecker:output_type -> milvus.proto.common.Status - 122, // 270: milvus.proto.query.QueryCoord.DeactivateChecker:output_type -> milvus.proto.common.Status - 82, // 271: milvus.proto.query.QueryCoord.ListQueryNode:output_type -> milvus.proto.query.ListQueryNodeResponse - 84, // 272: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:output_type -> milvus.proto.query.GetQueryNodeDistributionResponse - 122, // 273: milvus.proto.query.QueryCoord.SuspendBalance:output_type -> milvus.proto.common.Status - 122, // 274: milvus.proto.query.QueryCoord.ResumeBalance:output_type -> milvus.proto.common.Status - 88, // 275: milvus.proto.query.QueryCoord.CheckBalanceStatus:output_type -> milvus.proto.query.CheckBalanceStatusResponse - 122, // 276: milvus.proto.query.QueryCoord.SuspendNode:output_type -> milvus.proto.common.Status - 122, // 277: milvus.proto.query.QueryCoord.ResumeNode:output_type -> milvus.proto.common.Status - 122, // 278: milvus.proto.query.QueryCoord.TransferSegment:output_type -> milvus.proto.common.Status - 122, // 279: milvus.proto.query.QueryCoord.TransferChannel:output_type -> milvus.proto.common.Status - 122, // 280: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:output_type -> milvus.proto.common.Status - 122, // 281: milvus.proto.query.QueryCoord.UpdateLoadConfig:output_type -> milvus.proto.common.Status - 158, // 282: milvus.proto.query.QueryNode.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates - 159, // 283: milvus.proto.query.QueryNode.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse - 159, // 284: milvus.proto.query.QueryNode.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse - 122, // 285: milvus.proto.query.QueryNode.WatchDmChannels:output_type -> milvus.proto.common.Status - 122, // 286: milvus.proto.query.QueryNode.UnsubDmChannel:output_type -> milvus.proto.common.Status - 122, // 287: milvus.proto.query.QueryNode.LoadSegments:output_type -> milvus.proto.common.Status - 122, // 288: milvus.proto.query.QueryNode.ReleaseCollection:output_type -> milvus.proto.common.Status - 122, // 289: milvus.proto.query.QueryNode.LoadPartitions:output_type -> milvus.proto.common.Status - 122, // 290: milvus.proto.query.QueryNode.ReleasePartitions:output_type -> milvus.proto.common.Status - 122, // 291: milvus.proto.query.QueryNode.ReleaseSegments:output_type -> milvus.proto.common.Status - 19, // 292: milvus.proto.query.QueryNode.GetSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse - 122, // 293: milvus.proto.query.QueryNode.SyncReplicaSegments:output_type -> milvus.proto.common.Status - 160, // 294: milvus.proto.query.QueryNode.GetStatistics:output_type -> milvus.proto.internal.GetStatisticsResponse - 161, // 295: milvus.proto.query.QueryNode.Search:output_type -> milvus.proto.internal.SearchResults - 161, // 296: milvus.proto.query.QueryNode.SearchSegments:output_type -> milvus.proto.internal.SearchResults - 162, // 297: milvus.proto.query.QueryNode.Query:output_type -> milvus.proto.internal.RetrieveResults - 162, // 298: milvus.proto.query.QueryNode.QueryStream:output_type -> milvus.proto.internal.RetrieveResults - 162, // 299: milvus.proto.query.QueryNode.QuerySegments:output_type -> milvus.proto.internal.RetrieveResults - 162, // 300: milvus.proto.query.QueryNode.QueryStreamSegments:output_type -> milvus.proto.internal.RetrieveResults - 153, // 301: milvus.proto.query.QueryNode.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse - 154, // 302: milvus.proto.query.QueryNode.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse - 51, // 303: milvus.proto.query.QueryNode.GetDataDistribution:output_type -> milvus.proto.query.GetDataDistributionResponse - 122, // 304: milvus.proto.query.QueryNode.SyncDistribution:output_type -> milvus.proto.common.Status - 122, // 305: milvus.proto.query.QueryNode.Delete:output_type -> milvus.proto.common.Status - 70, // 306: milvus.proto.query.QueryNode.DeleteBatch:output_type -> milvus.proto.query.DeleteBatchResponse - 122, // 307: milvus.proto.query.QueryNode.UpdateSchema:output_type -> milvus.proto.common.Status - 163, // 308: milvus.proto.query.QueryNode.RunAnalyzer:output_type -> milvus.proto.milvus.RunAnalyzerResponse - 122, // 309: milvus.proto.query.QueryNode.DropIndex:output_type -> milvus.proto.common.Status - 245, // [245:310] is the sub-list for method output_type - 180, // [180:245] is the sub-list for method input_type - 180, // [180:180] is the sub-list for extension type_name - 180, // [180:180] is the sub-list for extension extendee - 0, // [0:180] is the sub-list for field type_name + 130, // 137: milvus.proto.query.DeleteBatchResponse.status:type_name -> milvus.proto.common.Status + 129, // 138: milvus.proto.query.ActivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 139: milvus.proto.query.DeactivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 140: milvus.proto.query.ListCheckersRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 141: milvus.proto.query.ListCheckersResponse.status:type_name -> milvus.proto.common.Status + 76, // 142: milvus.proto.query.ListCheckersResponse.checkerInfos:type_name -> milvus.proto.query.CheckerInfo + 141, // 143: milvus.proto.query.SegmentTarget.level:type_name -> milvus.proto.data.SegmentLevel + 77, // 144: milvus.proto.query.PartitionTarget.segments:type_name -> milvus.proto.query.SegmentTarget + 78, // 145: milvus.proto.query.ChannelTarget.partition_targets:type_name -> milvus.proto.query.PartitionTarget + 140, // 146: milvus.proto.query.ChannelTarget.seek_position:type_name -> milvus.proto.msg.MsgPosition + 140, // 147: milvus.proto.query.ChannelTarget.delete_checkpoint:type_name -> milvus.proto.msg.MsgPosition + 79, // 148: milvus.proto.query.CollectionTarget.Channel_targets:type_name -> milvus.proto.query.ChannelTarget + 129, // 149: milvus.proto.query.ListQueryNodeRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 150: milvus.proto.query.ListQueryNodeResponse.status:type_name -> milvus.proto.common.Status + 81, // 151: milvus.proto.query.ListQueryNodeResponse.nodeInfos:type_name -> milvus.proto.query.NodeInfo + 129, // 152: milvus.proto.query.GetQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 153: milvus.proto.query.GetQueryNodeDistributionResponse.status:type_name -> milvus.proto.common.Status + 129, // 154: milvus.proto.query.SuspendBalanceRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 155: milvus.proto.query.ResumeBalanceRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 156: milvus.proto.query.CheckBalanceStatusRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 157: milvus.proto.query.CheckBalanceStatusResponse.status:type_name -> milvus.proto.common.Status + 129, // 158: milvus.proto.query.SuspendNodeRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 159: milvus.proto.query.ResumeNodeRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 160: milvus.proto.query.TransferSegmentRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 161: milvus.proto.query.TransferChannelRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 162: milvus.proto.query.CheckQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 163: milvus.proto.query.UpdateLoadConfigRequest.base:type_name -> milvus.proto.common.MsgBase + 129, // 164: milvus.proto.query.UpdateSchemaRequest.base:type_name -> milvus.proto.common.MsgBase + 132, // 165: milvus.proto.query.UpdateSchemaRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 129, // 166: milvus.proto.query.RunAnalyzerRequest.base:type_name -> milvus.proto.common.MsgBase + 7, // 167: milvus.proto.query.HighlightQuery.type:type_name -> milvus.proto.query.HighlightQueryType + 98, // 168: milvus.proto.query.HighlightTask.options:type_name -> milvus.proto.query.HighlightOptions + 99, // 169: milvus.proto.query.HighlightTask.queries:type_name -> milvus.proto.query.HighlightQuery + 129, // 170: milvus.proto.query.GetHighlightRequest.base:type_name -> milvus.proto.common.MsgBase + 100, // 171: milvus.proto.query.GetHighlightRequest.tasks:type_name -> milvus.proto.query.HighlightTask + 102, // 172: milvus.proto.query.HighlightResult.fragments:type_name -> milvus.proto.query.HighlightFragment + 130, // 173: milvus.proto.query.GetHighlightResponse.status:type_name -> milvus.proto.common.Status + 103, // 174: milvus.proto.query.GetHighlightResponse.results:type_name -> milvus.proto.query.HighlightResult + 129, // 175: milvus.proto.query.ListLoadedSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 176: milvus.proto.query.ListLoadedSegmentsResponse.status:type_name -> milvus.proto.common.Status + 129, // 177: milvus.proto.query.DropIndexRequest.base:type_name -> milvus.proto.common.MsgBase + 145, // 178: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry.value:type_name -> milvus.proto.rg.ResourceGroupConfig + 138, // 179: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry.value:type_name -> milvus.proto.data.SegmentInfo + 148, // 180: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry.value:type_name -> milvus.proto.data.TextIndexStats + 149, // 181: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry.value:type_name -> milvus.proto.data.JsonKeyStats + 140, // 182: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry.value:type_name -> milvus.proto.msg.MsgPosition + 55, // 183: milvus.proto.query.LeaderView.SegmentDistEntry.value:type_name -> milvus.proto.query.SegmentDist + 140, // 184: milvus.proto.query.LeaderView.GrowingSegmentsEntry.value:type_name -> milvus.proto.msg.MsgPosition + 30, // 185: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry.value:type_name -> milvus.proto.query.FieldIndexInfo + 31, // 186: milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry.value:type_name -> milvus.proto.query.JsonStatsInfo + 60, // 187: milvus.proto.query.Replica.ChannelNodeInfosEntry.value:type_name -> milvus.proto.query.ChannelNodeInfo + 8, // 188: milvus.proto.query.QueryCoord.ShowLoadCollections:input_type -> milvus.proto.query.ShowCollectionsRequest + 10, // 189: milvus.proto.query.QueryCoord.ShowLoadPartitions:input_type -> milvus.proto.query.ShowPartitionsRequest + 15, // 190: milvus.proto.query.QueryCoord.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest + 16, // 191: milvus.proto.query.QueryCoord.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest + 12, // 192: milvus.proto.query.QueryCoord.LoadCollection:input_type -> milvus.proto.query.LoadCollectionRequest + 13, // 193: milvus.proto.query.QueryCoord.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest + 25, // 194: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:input_type -> milvus.proto.query.SyncNewCreatedPartitionRequest + 17, // 195: milvus.proto.query.QueryCoord.GetPartitionStates:input_type -> milvus.proto.query.GetPartitionStatesRequest + 19, // 196: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest + 41, // 197: milvus.proto.query.QueryCoord.LoadBalance:input_type -> milvus.proto.query.LoadBalanceRequest + 150, // 198: milvus.proto.query.QueryCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest + 151, // 199: milvus.proto.query.QueryCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest + 152, // 200: milvus.proto.query.QueryCoord.GetReplicas:input_type -> milvus.proto.milvus.GetReplicasRequest + 21, // 201: milvus.proto.query.QueryCoord.GetShardLeaders:input_type -> milvus.proto.query.GetShardLeadersRequest + 153, // 202: milvus.proto.query.QueryCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest + 154, // 203: milvus.proto.query.QueryCoord.CreateResourceGroup:input_type -> milvus.proto.milvus.CreateResourceGroupRequest + 23, // 204: milvus.proto.query.QueryCoord.UpdateResourceGroups:input_type -> milvus.proto.query.UpdateResourceGroupsRequest + 155, // 205: milvus.proto.query.QueryCoord.DropResourceGroup:input_type -> milvus.proto.milvus.DropResourceGroupRequest + 156, // 206: milvus.proto.query.QueryCoord.TransferNode:input_type -> milvus.proto.milvus.TransferNodeRequest + 65, // 207: milvus.proto.query.QueryCoord.TransferReplica:input_type -> milvus.proto.query.TransferReplicaRequest + 157, // 208: milvus.proto.query.QueryCoord.ListResourceGroups:input_type -> milvus.proto.milvus.ListResourceGroupsRequest + 66, // 209: milvus.proto.query.QueryCoord.DescribeResourceGroup:input_type -> milvus.proto.query.DescribeResourceGroupRequest + 105, // 210: milvus.proto.query.QueryCoord.ListLoadedSegments:input_type -> milvus.proto.query.ListLoadedSegmentsRequest + 74, // 211: milvus.proto.query.QueryCoord.ListCheckers:input_type -> milvus.proto.query.ListCheckersRequest + 72, // 212: milvus.proto.query.QueryCoord.ActivateChecker:input_type -> milvus.proto.query.ActivateCheckerRequest + 73, // 213: milvus.proto.query.QueryCoord.DeactivateChecker:input_type -> milvus.proto.query.DeactivateCheckerRequest + 82, // 214: milvus.proto.query.QueryCoord.ListQueryNode:input_type -> milvus.proto.query.ListQueryNodeRequest + 84, // 215: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:input_type -> milvus.proto.query.GetQueryNodeDistributionRequest + 86, // 216: milvus.proto.query.QueryCoord.SuspendBalance:input_type -> milvus.proto.query.SuspendBalanceRequest + 87, // 217: milvus.proto.query.QueryCoord.ResumeBalance:input_type -> milvus.proto.query.ResumeBalanceRequest + 88, // 218: milvus.proto.query.QueryCoord.CheckBalanceStatus:input_type -> milvus.proto.query.CheckBalanceStatusRequest + 90, // 219: milvus.proto.query.QueryCoord.SuspendNode:input_type -> milvus.proto.query.SuspendNodeRequest + 91, // 220: milvus.proto.query.QueryCoord.ResumeNode:input_type -> milvus.proto.query.ResumeNodeRequest + 92, // 221: milvus.proto.query.QueryCoord.TransferSegment:input_type -> milvus.proto.query.TransferSegmentRequest + 93, // 222: milvus.proto.query.QueryCoord.TransferChannel:input_type -> milvus.proto.query.TransferChannelRequest + 94, // 223: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:input_type -> milvus.proto.query.CheckQueryNodeDistributionRequest + 95, // 224: milvus.proto.query.QueryCoord.UpdateLoadConfig:input_type -> milvus.proto.query.UpdateLoadConfigRequest + 158, // 225: milvus.proto.query.QueryNode.GetComponentStates:input_type -> milvus.proto.milvus.GetComponentStatesRequest + 159, // 226: milvus.proto.query.QueryNode.GetTimeTickChannel:input_type -> milvus.proto.internal.GetTimeTickChannelRequest + 160, // 227: milvus.proto.query.QueryNode.GetStatisticsChannel:input_type -> milvus.proto.internal.GetStatisticsChannelRequest + 27, // 228: milvus.proto.query.QueryNode.WatchDmChannels:input_type -> milvus.proto.query.WatchDmChannelsRequest + 28, // 229: milvus.proto.query.QueryNode.UnsubDmChannel:input_type -> milvus.proto.query.UnsubDmChannelRequest + 32, // 230: milvus.proto.query.QueryNode.LoadSegments:input_type -> milvus.proto.query.LoadSegmentsRequest + 13, // 231: milvus.proto.query.QueryNode.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest + 15, // 232: milvus.proto.query.QueryNode.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest + 16, // 233: milvus.proto.query.QueryNode.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest + 33, // 234: milvus.proto.query.QueryNode.ReleaseSegments:input_type -> milvus.proto.query.ReleaseSegmentsRequest + 19, // 235: milvus.proto.query.QueryNode.GetSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest + 36, // 236: milvus.proto.query.QueryNode.SyncReplicaSegments:input_type -> milvus.proto.query.SyncReplicaSegmentsRequest + 14, // 237: milvus.proto.query.QueryNode.GetStatistics:input_type -> milvus.proto.query.GetStatisticsRequest + 34, // 238: milvus.proto.query.QueryNode.Search:input_type -> milvus.proto.query.SearchRequest + 34, // 239: milvus.proto.query.QueryNode.SearchSegments:input_type -> milvus.proto.query.SearchRequest + 35, // 240: milvus.proto.query.QueryNode.Query:input_type -> milvus.proto.query.QueryRequest + 35, // 241: milvus.proto.query.QueryNode.QueryStream:input_type -> milvus.proto.query.QueryRequest + 35, // 242: milvus.proto.query.QueryNode.QuerySegments:input_type -> milvus.proto.query.QueryRequest + 35, // 243: milvus.proto.query.QueryNode.QueryStreamSegments:input_type -> milvus.proto.query.QueryRequest + 150, // 244: milvus.proto.query.QueryNode.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest + 151, // 245: milvus.proto.query.QueryNode.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest + 51, // 246: milvus.proto.query.QueryNode.GetDataDistribution:input_type -> milvus.proto.query.GetDataDistributionRequest + 63, // 247: milvus.proto.query.QueryNode.SyncDistribution:input_type -> milvus.proto.query.SyncDistributionRequest + 69, // 248: milvus.proto.query.QueryNode.Delete:input_type -> milvus.proto.query.DeleteRequest + 70, // 249: milvus.proto.query.QueryNode.DeleteBatch:input_type -> milvus.proto.query.DeleteBatchRequest + 96, // 250: milvus.proto.query.QueryNode.UpdateSchema:input_type -> milvus.proto.query.UpdateSchemaRequest + 97, // 251: milvus.proto.query.QueryNode.RunAnalyzer:input_type -> milvus.proto.query.RunAnalyzerRequest + 101, // 252: milvus.proto.query.QueryNode.GetHighlight:input_type -> milvus.proto.query.GetHighlightRequest + 107, // 253: milvus.proto.query.QueryNode.DropIndex:input_type -> milvus.proto.query.DropIndexRequest + 9, // 254: milvus.proto.query.QueryCoord.ShowLoadCollections:output_type -> milvus.proto.query.ShowCollectionsResponse + 11, // 255: milvus.proto.query.QueryCoord.ShowLoadPartitions:output_type -> milvus.proto.query.ShowPartitionsResponse + 130, // 256: milvus.proto.query.QueryCoord.LoadPartitions:output_type -> milvus.proto.common.Status + 130, // 257: milvus.proto.query.QueryCoord.ReleasePartitions:output_type -> milvus.proto.common.Status + 130, // 258: milvus.proto.query.QueryCoord.LoadCollection:output_type -> milvus.proto.common.Status + 130, // 259: milvus.proto.query.QueryCoord.ReleaseCollection:output_type -> milvus.proto.common.Status + 130, // 260: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:output_type -> milvus.proto.common.Status + 18, // 261: milvus.proto.query.QueryCoord.GetPartitionStates:output_type -> milvus.proto.query.GetPartitionStatesResponse + 20, // 262: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse + 130, // 263: milvus.proto.query.QueryCoord.LoadBalance:output_type -> milvus.proto.common.Status + 161, // 264: milvus.proto.query.QueryCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse + 162, // 265: milvus.proto.query.QueryCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse + 163, // 266: milvus.proto.query.QueryCoord.GetReplicas:output_type -> milvus.proto.milvus.GetReplicasResponse + 22, // 267: milvus.proto.query.QueryCoord.GetShardLeaders:output_type -> milvus.proto.query.GetShardLeadersResponse + 164, // 268: milvus.proto.query.QueryCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse + 130, // 269: milvus.proto.query.QueryCoord.CreateResourceGroup:output_type -> milvus.proto.common.Status + 130, // 270: milvus.proto.query.QueryCoord.UpdateResourceGroups:output_type -> milvus.proto.common.Status + 130, // 271: milvus.proto.query.QueryCoord.DropResourceGroup:output_type -> milvus.proto.common.Status + 130, // 272: milvus.proto.query.QueryCoord.TransferNode:output_type -> milvus.proto.common.Status + 130, // 273: milvus.proto.query.QueryCoord.TransferReplica:output_type -> milvus.proto.common.Status + 165, // 274: milvus.proto.query.QueryCoord.ListResourceGroups:output_type -> milvus.proto.milvus.ListResourceGroupsResponse + 67, // 275: milvus.proto.query.QueryCoord.DescribeResourceGroup:output_type -> milvus.proto.query.DescribeResourceGroupResponse + 106, // 276: milvus.proto.query.QueryCoord.ListLoadedSegments:output_type -> milvus.proto.query.ListLoadedSegmentsResponse + 75, // 277: milvus.proto.query.QueryCoord.ListCheckers:output_type -> milvus.proto.query.ListCheckersResponse + 130, // 278: milvus.proto.query.QueryCoord.ActivateChecker:output_type -> milvus.proto.common.Status + 130, // 279: milvus.proto.query.QueryCoord.DeactivateChecker:output_type -> milvus.proto.common.Status + 83, // 280: milvus.proto.query.QueryCoord.ListQueryNode:output_type -> milvus.proto.query.ListQueryNodeResponse + 85, // 281: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:output_type -> milvus.proto.query.GetQueryNodeDistributionResponse + 130, // 282: milvus.proto.query.QueryCoord.SuspendBalance:output_type -> milvus.proto.common.Status + 130, // 283: milvus.proto.query.QueryCoord.ResumeBalance:output_type -> milvus.proto.common.Status + 89, // 284: milvus.proto.query.QueryCoord.CheckBalanceStatus:output_type -> milvus.proto.query.CheckBalanceStatusResponse + 130, // 285: milvus.proto.query.QueryCoord.SuspendNode:output_type -> milvus.proto.common.Status + 130, // 286: milvus.proto.query.QueryCoord.ResumeNode:output_type -> milvus.proto.common.Status + 130, // 287: milvus.proto.query.QueryCoord.TransferSegment:output_type -> milvus.proto.common.Status + 130, // 288: milvus.proto.query.QueryCoord.TransferChannel:output_type -> milvus.proto.common.Status + 130, // 289: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:output_type -> milvus.proto.common.Status + 130, // 290: milvus.proto.query.QueryCoord.UpdateLoadConfig:output_type -> milvus.proto.common.Status + 166, // 291: milvus.proto.query.QueryNode.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates + 167, // 292: milvus.proto.query.QueryNode.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse + 167, // 293: milvus.proto.query.QueryNode.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse + 130, // 294: milvus.proto.query.QueryNode.WatchDmChannels:output_type -> milvus.proto.common.Status + 130, // 295: milvus.proto.query.QueryNode.UnsubDmChannel:output_type -> milvus.proto.common.Status + 130, // 296: milvus.proto.query.QueryNode.LoadSegments:output_type -> milvus.proto.common.Status + 130, // 297: milvus.proto.query.QueryNode.ReleaseCollection:output_type -> milvus.proto.common.Status + 130, // 298: milvus.proto.query.QueryNode.LoadPartitions:output_type -> milvus.proto.common.Status + 130, // 299: milvus.proto.query.QueryNode.ReleasePartitions:output_type -> milvus.proto.common.Status + 130, // 300: milvus.proto.query.QueryNode.ReleaseSegments:output_type -> milvus.proto.common.Status + 20, // 301: milvus.proto.query.QueryNode.GetSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse + 130, // 302: milvus.proto.query.QueryNode.SyncReplicaSegments:output_type -> milvus.proto.common.Status + 168, // 303: milvus.proto.query.QueryNode.GetStatistics:output_type -> milvus.proto.internal.GetStatisticsResponse + 169, // 304: milvus.proto.query.QueryNode.Search:output_type -> milvus.proto.internal.SearchResults + 169, // 305: milvus.proto.query.QueryNode.SearchSegments:output_type -> milvus.proto.internal.SearchResults + 170, // 306: milvus.proto.query.QueryNode.Query:output_type -> milvus.proto.internal.RetrieveResults + 170, // 307: milvus.proto.query.QueryNode.QueryStream:output_type -> milvus.proto.internal.RetrieveResults + 170, // 308: milvus.proto.query.QueryNode.QuerySegments:output_type -> milvus.proto.internal.RetrieveResults + 170, // 309: milvus.proto.query.QueryNode.QueryStreamSegments:output_type -> milvus.proto.internal.RetrieveResults + 161, // 310: milvus.proto.query.QueryNode.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse + 162, // 311: milvus.proto.query.QueryNode.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse + 52, // 312: milvus.proto.query.QueryNode.GetDataDistribution:output_type -> milvus.proto.query.GetDataDistributionResponse + 130, // 313: milvus.proto.query.QueryNode.SyncDistribution:output_type -> milvus.proto.common.Status + 130, // 314: milvus.proto.query.QueryNode.Delete:output_type -> milvus.proto.common.Status + 71, // 315: milvus.proto.query.QueryNode.DeleteBatch:output_type -> milvus.proto.query.DeleteBatchResponse + 130, // 316: milvus.proto.query.QueryNode.UpdateSchema:output_type -> milvus.proto.common.Status + 171, // 317: milvus.proto.query.QueryNode.RunAnalyzer:output_type -> milvus.proto.milvus.RunAnalyzerResponse + 104, // 318: milvus.proto.query.QueryNode.GetHighlight:output_type -> milvus.proto.query.GetHighlightResponse + 130, // 319: milvus.proto.query.QueryNode.DropIndex:output_type -> milvus.proto.common.Status + 254, // [254:320] is the sub-list for method output_type + 188, // [188:254] is the sub-list for method input_type + 188, // [188:188] is the sub-list for extension type_name + 188, // [188:188] is the sub-list for extension extendee + 0, // [0:188] is the sub-list for field type_name } func init() { file_query_coord_proto_init() } @@ -11423,7 +12019,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListLoadedSegmentsRequest); i { + switch v := v.(*HighlightOptions); i { case 0: return &v.state case 1: @@ -11435,7 +12031,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListLoadedSegmentsResponse); i { + switch v := v.(*HighlightQuery); i { case 0: return &v.state case 1: @@ -11447,6 +12043,90 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HighlightTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetHighlightRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HighlightFragment); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HighlightResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetHighlightResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListLoadedSegmentsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListLoadedSegmentsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DropIndexRequest); i { case 0: return &v.state @@ -11464,8 +12144,8 @@ func file_query_coord_proto_init() { File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_query_coord_proto_rawDesc, - NumEnums: 7, - NumMessages: 114, + NumEnums: 8, + NumMessages: 121, NumExtensions: 0, NumServices: 2, }, diff --git a/pkg/proto/querypb/query_coord_grpc.pb.go b/pkg/proto/querypb/query_coord_grpc.pb.go index 17620b7ddf..e1f53a0e94 100644 --- a/pkg/proto/querypb/query_coord_grpc.pb.go +++ b/pkg/proto/querypb/query_coord_grpc.pb.go @@ -1478,6 +1478,7 @@ const ( QueryNode_DeleteBatch_FullMethodName = "/milvus.proto.query.QueryNode/DeleteBatch" QueryNode_UpdateSchema_FullMethodName = "/milvus.proto.query.QueryNode/UpdateSchema" QueryNode_RunAnalyzer_FullMethodName = "/milvus.proto.query.QueryNode/RunAnalyzer" + QueryNode_GetHighlight_FullMethodName = "/milvus.proto.query.QueryNode/GetHighlight" QueryNode_DropIndex_FullMethodName = "/milvus.proto.query.QueryNode/DropIndex" ) @@ -1515,6 +1516,7 @@ type QueryNodeClient interface { DeleteBatch(ctx context.Context, in *DeleteBatchRequest, opts ...grpc.CallOption) (*DeleteBatchResponse, error) UpdateSchema(ctx context.Context, in *UpdateSchemaRequest, opts ...grpc.CallOption) (*commonpb.Status, error) RunAnalyzer(ctx context.Context, in *RunAnalyzerRequest, opts ...grpc.CallOption) (*milvuspb.RunAnalyzerResponse, error) + GetHighlight(ctx context.Context, in *GetHighlightRequest, opts ...grpc.CallOption) (*GetHighlightResponse, error) DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) } @@ -1815,6 +1817,15 @@ func (c *queryNodeClient) RunAnalyzer(ctx context.Context, in *RunAnalyzerReques return out, nil } +func (c *queryNodeClient) GetHighlight(ctx context.Context, in *GetHighlightRequest, opts ...grpc.CallOption) (*GetHighlightResponse, error) { + out := new(GetHighlightResponse) + err := c.cc.Invoke(ctx, QueryNode_GetHighlight_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryNodeClient) DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { out := new(commonpb.Status) err := c.cc.Invoke(ctx, QueryNode_DropIndex_FullMethodName, in, out, opts...) @@ -1858,6 +1869,7 @@ type QueryNodeServer interface { DeleteBatch(context.Context, *DeleteBatchRequest) (*DeleteBatchResponse, error) UpdateSchema(context.Context, *UpdateSchemaRequest) (*commonpb.Status, error) RunAnalyzer(context.Context, *RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error) + GetHighlight(context.Context, *GetHighlightRequest) (*GetHighlightResponse, error) DropIndex(context.Context, *DropIndexRequest) (*commonpb.Status, error) } @@ -1946,6 +1958,9 @@ func (UnimplementedQueryNodeServer) UpdateSchema(context.Context, *UpdateSchemaR func (UnimplementedQueryNodeServer) RunAnalyzer(context.Context, *RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RunAnalyzer not implemented") } +func (UnimplementedQueryNodeServer) GetHighlight(context.Context, *GetHighlightRequest) (*GetHighlightResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetHighlight not implemented") +} func (UnimplementedQueryNodeServer) DropIndex(context.Context, *DropIndexRequest) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method DropIndex not implemented") } @@ -2453,6 +2468,24 @@ func _QueryNode_RunAnalyzer_Handler(srv interface{}, ctx context.Context, dec fu return interceptor(ctx, in, info, handler) } +func _QueryNode_GetHighlight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetHighlightRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryNodeServer).GetHighlight(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: QueryNode_GetHighlight_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryNodeServer).GetHighlight(ctx, req.(*GetHighlightRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _QueryNode_DropIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DropIndexRequest) if err := dec(in); err != nil { @@ -2578,6 +2611,10 @@ var QueryNode_ServiceDesc = grpc.ServiceDesc{ MethodName: "RunAnalyzer", Handler: _QueryNode_RunAnalyzer_Handler, }, + { + MethodName: "GetHighlight", + Handler: _QueryNode_GetHighlight_Handler, + }, { MethodName: "DropIndex", Handler: _QueryNode_DropIndex_Handler,