feat: [2.5] Support get segment binlogs info with new interface GetSegmentsInfo (#40466)

issue: #40341 

master pr: #40464

---------

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

internal/distributed/proxy/client/client.go

@@ -233,3 +233,9 @@ func (c *Client) InvalidateShardLeaderCache(ctx context.Context, req *proxypb.In
 		return client.InvalidateShardLeaderCache(ctx, req)
 	})
 }
+
+func (c *Client) GetSegmentsInfo(ctx context.Context, req *internalpb.GetSegmentsInfoRequest, opts ...grpc.CallOption) (*internalpb.GetSegmentsInfoResponse, error) {
+	return wrapGrpcCall(ctx, c, func(client proxypb.ProxyClient) (*internalpb.GetSegmentsInfoResponse, error) {
+		return client.GetSegmentsInfo(ctx, req)
+	})
+}

internal/distributed/proxy/client/client_test.go

@@ -499,3 +499,24 @@ func Test_InvalidateShardLeaderCache(t *testing.T) {
 	_, err = client.InvalidateShardLeaderCache(ctx, &proxypb.InvalidateShardLeaderCacheRequest{})
 	assert.ErrorIs(t, err, context.DeadlineExceeded)
 }
+
+func Test_GetSegmentsInfo(t *testing.T) {
+	paramtable.Init()
+	ctx := context.Background()
+
+	client, err := NewClient(ctx, "test", 1)
+	assert.NoError(t, err)
+	defer client.Close()
+
+	mockProxy := mocks.NewMockProxyClient(t)
+	mockGrpcClient := mocks.NewMockGrpcClient[proxypb.ProxyClient](t)
+	mockGrpcClient.EXPECT().Close().Return(nil)
+	mockGrpcClient.EXPECT().ReCall(mock.Anything, mock.Anything).RunAndReturn(func(ctx context.Context, f func(proxypb.ProxyClient) (interface{}, error)) (interface{}, error) {
+		return f(mockProxy)
+	})
+	client.(*Client).grpcClient = mockGrpcClient
+
+	mockProxy.EXPECT().GetSegmentsInfo(mock.Anything, mock.Anything).Return(&internalpb.GetSegmentsInfoResponse{Status: merr.Success()}, nil)
+	_, err = client.GetSegmentsInfo(ctx, &internalpb.GetSegmentsInfoRequest{})
+	assert.Nil(t, err)
+}

internal/distributed/proxy/httpserver/constant.go

@@ -37,6 +37,7 @@ const (
 	PrivilegeGroupCategory  = "/privilege_groups/"
 	ResourceGroupCategory   = "/resource_groups/"
 	CollectionFieldCategory = "/collections/fields/"
+	SegmentCategory         = "/segments/"
 
 	ListAction           = "list"
 	HasAction            = "has"

internal/distributed/proxy/httpserver/handler_v2.go

@@ -202,6 +202,9 @@ func (h *HandlersV2) RegisterRoutesToV2(router gin.IRouter) {
 	router.POST(ResourceGroupCategory+DescribeAction, timeoutMiddleware(wrapperPost(func() any { return &ResourceGroupReq{} }, wrapperTraceLog(h.describeResourceGroup))))
 	router.POST(ResourceGroupCategory+ListAction, timeoutMiddleware(wrapperPost(func() any { return &EmptyReq{} }, wrapperTraceLog(h.listResourceGroups))))
 	router.POST(ResourceGroupCategory+TransferReplicaAction, timeoutMiddleware(wrapperPost(func() any { return &TransferReplicaReq{} }, wrapperTraceLog(h.transferReplica))))
+
+	// segment group
+	router.POST(SegmentCategory+DescribeAction, timeoutMiddleware(wrapperPost(func() any { return &GetSegmentsInfoReq{} }, wrapperTraceLog(h.getSegmentsInfo))))
 }
 
 type (
@@ -2612,3 +2615,50 @@ func (h *HandlersV2) GetCollectionSchema(ctx context.Context, c *gin.Context, db
 	response, _ := descResp.(*milvuspb.DescribeCollectionResponse)
 	return response.Schema, nil
 }
+
+func (h *HandlersV2) getSegmentsInfo(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) {
+	httpReq := anyReq.(*GetSegmentsInfoReq)
+	req := &internalpb.GetSegmentsInfoRequest{
+		DbName:       httpReq.GetDbName(),
+		CollectionID: httpReq.GetCollectionID(),
+		SegmentIDs:   httpReq.GetSegmentIDs(),
+	}
+
+	resp, err := wrapperProxy(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/GetSegmentsInfo", func(reqCtx context.Context, req any) (any, error) {
+		return h.proxy.GetSegmentsInfo(reqCtx, req.(*internalpb.GetSegmentsInfoRequest))
+	})
+
+	getLogs := func(binlogs []*internalpb.FieldBinlog) []interface{} {
+		logIDs := make([]interface{}, 0, len(binlogs))
+		for _, binlog := range binlogs {
+			details := make(map[string]interface{})
+			details["fieldID"] = binlog.GetFieldID()
+			details["logIDs"] = binlog.GetLogIDs()
+			logIDs = append(logIDs, details)
+		}
+		return logIDs
+	}
+	if err == nil {
+		response := resp.(*internalpb.GetSegmentsInfoResponse)
+		returnData := make(map[string]interface{})
+		infos := make([]map[string]interface{}, 0)
+		for _, segInfo := range response.GetSegmentInfos() {
+			info := make(map[string]interface{})
+			info["segmentID"] = segInfo.GetSegmentID()
+			info["collectionID"] = segInfo.GetCollectionID()
+			info["partitionID"] = segInfo.GetPartitionID()
+			info["vChannel"] = segInfo.GetVChannel()
+			info["numRows"] = segInfo.GetNumRows()
+			info["state"] = segInfo.GetState()
+			info["level"] = segInfo.GetLevel()
+			info["isSorted"] = segInfo.GetIsSorted()
+			info["insertLogs"] = getLogs(segInfo.GetInsertLogs())
+			info["deltaLogs"] = getLogs(segInfo.GetDeltaLogs())
+			info["statsLogs"] = getLogs(segInfo.GetStatsLogs())
+			infos = append(infos, info)
+		}
+		returnData["segmentInfos"] = infos
+		HTTPReturn(c, http.StatusOK, gin.H{HTTPReturnCode: merr.Code(nil), HTTPReturnData: returnData})
+	}
+	return resp, err
+}

internal/distributed/proxy/httpserver/handler_v2_test.go

@@ -1862,6 +1862,51 @@ func TestMethodPost(t *testing.T) {
 		Reason:   "",
 		Progress: 100,
 	}, nil).Twice()
+	mp.EXPECT().GetSegmentsInfo(mock.Anything, mock.Anything).Return(&internalpb.GetSegmentsInfoResponse{
+		Status: &StatusSuccess,
+		SegmentInfos: []*internalpb.SegmentInfo{
+			{
+				SegmentID:    3,
+				CollectionID: 1,
+				PartitionID:  2,
+				NumRows:      1000,
+				VChannel:     "ch-1",
+				State:        commonpb.SegmentState_Flushed,
+				Level:        commonpb.SegmentLevel_L1,
+				IsSorted:     true,
+				InsertLogs: []*internalpb.FieldBinlog{
+					{
+						FieldID: 0,
+						LogIDs:  []int64{1, 5, 9},
+					},
+					{
+						FieldID: 1,
+						LogIDs:  []int64{2, 6, 10},
+					},
+					{
+						FieldID: 100,
+						LogIDs:  []int64{3, 7, 11},
+					},
+					{
+						FieldID: 101,
+						LogIDs:  []int64{4, 8, 12},
+					},
+				},
+				DeltaLogs: []*internalpb.FieldBinlog{
+					{
+						FieldID: 100,
+						LogIDs:  []int64{13, 14, 15},
+					},
+				},
+				StatsLogs: []*internalpb.FieldBinlog{
+					{
+						FieldID: 100,
+						LogIDs:  []int64{16},
+					},
+				},
+			},
+		},
+	}, nil).Once()
 	testEngine := initHTTPServerV2(mp, false)
 	queryTestCases := []rawTestCase{}
 	queryTestCases = append(queryTestCases, rawTestCase{
@@ -1950,6 +1995,9 @@ func TestMethodPost(t *testing.T) {
 	queryTestCases = append(queryTestCases, rawTestCase{
 		path: versionalV2(PrivilegeGroupCategory, RemovePrivilegesFromGroupAction),
 	})
+	queryTestCases = append(queryTestCases, rawTestCase{
+		path: versionalV2(SegmentCategory, DescribeAction),
+	})
 
 	for _, testcase := range queryTestCases {
 		t.Run(testcase.path, func(t *testing.T) {

internal/distributed/proxy/httpserver/request_v2.go

@@ -665,3 +665,21 @@ func (req *TransferReplicaReq) GetCollectionName() string {
 func (req *TransferReplicaReq) GetReplicaNum() int64 {
 	return req.ReplicaNum
 }
+
+type GetSegmentsInfoReq struct {
+	DbName       string  `json:"dbName"`
+	CollectionID int64   `json:"collectionID"`
+	SegmentIDs   []int64 `json:"segmentIDs"`
+}
+
+func (req *GetSegmentsInfoReq) GetDbName() string {
+	return req.DbName
+}
+
+func (req *GetSegmentsInfoReq) GetCollectionID() int64 {
+	return req.CollectionID
+}
+
+func (req *GetSegmentsInfoReq) GetSegmentIDs() []int64 {
+	return req.SegmentIDs
+}

internal/distributed/proxy/service.go

@@ -1157,3 +1157,7 @@ func (s *Server) InvalidateShardLeaderCache(ctx context.Context, req *proxypb.In
 func (s *Server) DescribeDatabase(ctx context.Context, req *milvuspb.DescribeDatabaseRequest) (*milvuspb.DescribeDatabaseResponse, error) {
 	return s.proxy.DescribeDatabase(ctx, req)
 }
+
+func (s *Server) GetSegmentsInfo(ctx context.Context, req *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error) {
+	return s.proxy.GetSegmentsInfo(ctx, req)
+}

internal/mocks/mock_proxy.go

@@ -3558,6 +3558,65 @@ func (_c *MockProxy_GetReplicas_Call) RunAndReturn(run func(context.Context, *mi
 	return _c
 }
 
+// GetSegmentsInfo provides a mock function with given fields: _a0, _a1
+func (_m *MockProxy) GetSegmentsInfo(_a0 context.Context, _a1 *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSegmentsInfo")
+	}
+
+	var r0 *internalpb.GetSegmentsInfoResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetSegmentsInfoRequest) *internalpb.GetSegmentsInfoResponse); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*internalpb.GetSegmentsInfoResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetSegmentsInfoRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockProxy_GetSegmentsInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentsInfo'
+type MockProxy_GetSegmentsInfo_Call struct {
+	*mock.Call
+}
+
+// GetSegmentsInfo is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *internalpb.GetSegmentsInfoRequest
+func (_e *MockProxy_Expecter) GetSegmentsInfo(_a0 interface{}, _a1 interface{}) *MockProxy_GetSegmentsInfo_Call {
+	return &MockProxy_GetSegmentsInfo_Call{Call: _e.mock.On("GetSegmentsInfo", _a0, _a1)}
+}
+
+func (_c *MockProxy_GetSegmentsInfo_Call) Run(run func(_a0 context.Context, _a1 *internalpb.GetSegmentsInfoRequest)) *MockProxy_GetSegmentsInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*internalpb.GetSegmentsInfoRequest))
+	})
+	return _c
+}
+
+func (_c *MockProxy_GetSegmentsInfo_Call) Return(_a0 *internalpb.GetSegmentsInfoResponse, _a1 error) *MockProxy_GetSegmentsInfo_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockProxy_GetSegmentsInfo_Call) RunAndReturn(run func(context.Context, *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error)) *MockProxy_GetSegmentsInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // GetStatisticsChannel provides a mock function with given fields: _a0, _a1
 func (_m *MockProxy) GetStatisticsChannel(_a0 context.Context, _a1 *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
 	ret := _m.Called(_a0, _a1)

internal/mocks/mock_proxy_client.go

@@ -372,6 +372,80 @@ func (_c *MockProxyClient_GetProxyMetrics_Call) RunAndReturn(run func(context.Co
 	return _c
 }
 
+// GetSegmentsInfo provides a mock function with given fields: ctx, in, opts
+func (_m *MockProxyClient) GetSegmentsInfo(ctx context.Context, in *internalpb.GetSegmentsInfoRequest, opts ...grpc.CallOption) (*internalpb.GetSegmentsInfoResponse, 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 GetSegmentsInfo")
+	}
+
+	var r0 *internalpb.GetSegmentsInfoResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetSegmentsInfoRequest, ...grpc.CallOption) (*internalpb.GetSegmentsInfoResponse, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetSegmentsInfoRequest, ...grpc.CallOption) *internalpb.GetSegmentsInfoResponse); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*internalpb.GetSegmentsInfoResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetSegmentsInfoRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockProxyClient_GetSegmentsInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentsInfo'
+type MockProxyClient_GetSegmentsInfo_Call struct {
+	*mock.Call
+}
+
+// GetSegmentsInfo is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *internalpb.GetSegmentsInfoRequest
+//   - opts ...grpc.CallOption
+func (_e *MockProxyClient_Expecter) GetSegmentsInfo(ctx interface{}, in interface{}, opts ...interface{}) *MockProxyClient_GetSegmentsInfo_Call {
+	return &MockProxyClient_GetSegmentsInfo_Call{Call: _e.mock.On("GetSegmentsInfo",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockProxyClient_GetSegmentsInfo_Call) Run(run func(ctx context.Context, in *internalpb.GetSegmentsInfoRequest, opts ...grpc.CallOption)) *MockProxyClient_GetSegmentsInfo_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].(*internalpb.GetSegmentsInfoRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockProxyClient_GetSegmentsInfo_Call) Return(_a0 *internalpb.GetSegmentsInfoResponse, _a1 error) *MockProxyClient_GetSegmentsInfo_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockProxyClient_GetSegmentsInfo_Call) RunAndReturn(run func(context.Context, *internalpb.GetSegmentsInfoRequest, ...grpc.CallOption) (*internalpb.GetSegmentsInfoResponse, error)) *MockProxyClient_GetSegmentsInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // GetStatisticsChannel provides a mock function with given fields: ctx, in, opts
 func (_m *MockProxyClient) GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
 	_va := make([]interface{}, len(opts))

internal/mocks/mock_rootcoord.go

@@ -1926,6 +1926,38 @@ func (_c *RootCoord_GetTimeTickChannel_Call) RunAndReturn(run func(context.Conte
 	return _c
 }
 
+// GracefulStop provides a mock function with given fields:
+func (_m *RootCoord) GracefulStop() {
+	_m.Called()
+}
+
+// RootCoord_GracefulStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GracefulStop'
+type RootCoord_GracefulStop_Call struct {
+	*mock.Call
+}
+
+// GracefulStop is a helper method to define mock.On call
+func (_e *RootCoord_Expecter) GracefulStop() *RootCoord_GracefulStop_Call {
+	return &RootCoord_GracefulStop_Call{Call: _e.mock.On("GracefulStop")}
+}
+
+func (_c *RootCoord_GracefulStop_Call) Run(run func()) *RootCoord_GracefulStop_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *RootCoord_GracefulStop_Call) Return() *RootCoord_GracefulStop_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *RootCoord_GracefulStop_Call) RunAndReturn(run func()) *RootCoord_GracefulStop_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // HasCollection provides a mock function with given fields: _a0, _a1
 func (_m *RootCoord) HasCollection(_a0 context.Context, _a1 *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
 	ret := _m.Called(_a0, _a1)

internal/proxy/impl.go

@@ -4325,6 +4325,92 @@ func (node *Proxy) GetPersistentSegmentInfo(ctx context.Context, req *milvuspb.G
 	return resp, nil
 }
 
+func (node *Proxy) GetSegmentsInfo(ctx context.Context, req *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error) {
+	ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-GetSegmentsInfo")
+	defer sp.End()
+
+	log := log.Ctx(ctx)
+	log.Debug("GetSegmentsInfo",
+		zap.String("role", typeutil.ProxyRole),
+		zap.String("db", req.DbName),
+		zap.Int64("collectionID", req.GetCollectionID()),
+		zap.Int64s("segmentIDs", req.GetSegmentIDs()))
+
+	resp := &internalpb.GetSegmentsInfoResponse{
+		Status: merr.Success(),
+	}
+	if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
+		resp.Status = merr.Status(err)
+		return resp, nil
+	}
+	method := "GetSegmentsInfo"
+	tr := timerecord.NewTimeRecorder(method)
+	nodeID := fmt.Sprint(paramtable.GetNodeID())
+	collection := fmt.Sprint(req.GetCollectionID())
+	defer func() {
+		metrics.ProxyFunctionCall.WithLabelValues(nodeID, method, metrics.TotalLabel, req.GetDbName(), collection).Inc()
+		if resp.GetStatus().GetCode() != 0 {
+			log.Warn("import failed", zap.String("err", resp.GetStatus().GetReason()))
+			metrics.ProxyFunctionCall.WithLabelValues(nodeID, method, metrics.FailLabel, req.GetDbName(), collection).Inc()
+		} else {
+			metrics.ProxyFunctionCall.WithLabelValues(nodeID, method, metrics.SuccessLabel, req.GetDbName(), collection).Inc()
+		}
+		metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
+	}()
+
+	infoResp, err := node.dataCoord.GetSegmentInfo(ctx, &datapb.GetSegmentInfoRequest{
+		SegmentIDs:       req.GetSegmentIDs(),
+		IncludeUnHealthy: true,
+	})
+	if err != nil {
+		log.Warn("GetSegmentInfo fail",
+			zap.Error(err))
+		resp.Status = merr.Status(err)
+		return resp, nil
+	}
+	err = merr.Error(infoResp.GetStatus())
+	if err != nil {
+		resp.Status = merr.Status(err)
+		return resp, nil
+	}
+	log.Debug("GetPersistentSegmentInfo",
+		zap.Int("len(infos)", len(infoResp.Infos)),
+		zap.Any("status", infoResp.Status))
+	getLogIDs := func(binlogs []*datapb.FieldBinlog) []*internalpb.FieldBinlog {
+		logIDs := make([]*internalpb.FieldBinlog, 0, len(binlogs))
+		for _, fb := range binlogs {
+			fieldLogIDs := make([]int64, 0, len(fb.GetBinlogs()))
+			for _, b := range fb.GetBinlogs() {
+				fieldLogIDs = append(fieldLogIDs, b.GetLogID())
+			}
+			logIDs = append(logIDs, &internalpb.FieldBinlog{
+				FieldID: fb.GetFieldID(),
+				LogIDs:  fieldLogIDs,
+			})
+		}
+		return logIDs
+	}
+	segmentInfos := make([]*internalpb.SegmentInfo, 0, len(req.GetSegmentIDs()))
+	for _, info := range infoResp.GetInfos() {
+		segmentInfos = append(segmentInfos, &internalpb.SegmentInfo{
+			SegmentID:    info.GetID(),
+			CollectionID: info.GetCollectionID(),
+			PartitionID:  info.GetPartitionID(),
+			VChannel:     info.GetInsertChannel(),
+			NumRows:      info.GetNumOfRows(),
+			State:        info.GetState(),
+			Level:        commonpb.SegmentLevel(info.GetLevel()),
+			IsSorted:     info.GetIsSorted(),
+			InsertLogs:   getLogIDs(info.GetBinlogs()),
+			DeltaLogs:    getLogIDs(info.GetDeltalogs()),
+			StatsLogs:    getLogIDs(info.GetStatslogs()),
+		})
+	}
+
+	resp.SegmentInfos = segmentInfos
+	return resp, nil
+}
+
 // GetQuerySegmentInfo gets segment information from QueryCoord.
 func (node *Proxy) GetQuerySegmentInfo(ctx context.Context, req *milvuspb.GetQuerySegmentInfoRequest) (*milvuspb.GetQuerySegmentInfoResponse, error) {
 	ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-GetQuerySegmentInfo")

internal/proxy/impl_test.go

@@ -2194,3 +2194,101 @@ func TestAlterCollectionReplicateProperty(t *testing.T) {
 	assert.NoError(t, err)
 	assert.True(t, merr.Ok(statusResp))
 }
+
+func Test_GetSegmentsInfo(t *testing.T) {
+	t.Run("normal case", func(t *testing.T) {
+		mockDataCoord := mocks.NewMockDataCoordClient(t)
+		mockDataCoord.EXPECT().GetSegmentInfo(mock.Anything, mock.Anything).RunAndReturn(func(ctx context.Context, request *datapb.GetSegmentInfoRequest, opts ...grpc.CallOption) (*datapb.GetSegmentInfoResponse, error) {
+			segmentInfos := make([]*datapb.SegmentInfo, 0)
+			for _, segID := range request.SegmentIDs {
+				segmentInfos = append(segmentInfos, &datapb.SegmentInfo{
+					ID:            segID,
+					CollectionID:  1,
+					PartitionID:   2,
+					InsertChannel: "ch-1",
+					NumOfRows:     1024,
+					State:         commonpb.SegmentState_Flushed,
+					MaxRowNum:     65535,
+					Binlogs: []*datapb.FieldBinlog{
+						{
+							FieldID: 0,
+							Binlogs: []*datapb.Binlog{
+								{
+									LogID: 1,
+								},
+								{
+									LogID: 5,
+								},
+							},
+						},
+						{
+							FieldID: 1,
+							Binlogs: []*datapb.Binlog{
+								{
+									LogID: 2,
+								},
+								{
+									LogID: 6,
+								},
+							},
+						},
+						{
+							FieldID: 100,
+							Binlogs: []*datapb.Binlog{
+								{
+									LogID: 3,
+								},
+								{
+									LogID: 7,
+								},
+							},
+						},
+						{
+							FieldID: 101,
+							Binlogs: []*datapb.Binlog{
+								{
+									LogID: 4,
+								},
+								{
+									LogID: 8,
+								},
+							},
+						},
+					},
+					Statslogs: nil,
+					Deltalogs: nil,
+					Level:     datapb.SegmentLevel_L1,
+					IsSorted:  true,
+				})
+			}
+
+			return &datapb.GetSegmentInfoResponse{
+				Status: merr.Success(),
+				Infos:  segmentInfos,
+			}, nil
+		})
+
+		ctx := context.Background()
+		p := &Proxy{
+			ctx:       ctx,
+			dataCoord: mockDataCoord,
+		}
+		p.UpdateStateCode(commonpb.StateCode_Healthy)
+
+		resp, err := p.GetSegmentsInfo(ctx, &internalpb.GetSegmentsInfoRequest{
+			CollectionID: 1,
+			SegmentIDs:   []int64{4, 5, 6},
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.GetErrorCode())
+		assert.Equal(t, 3, len(resp.GetSegmentInfos()))
+		assert.Equal(t, 4, len(resp.GetSegmentInfos()[0].GetInsertLogs()))
+		assert.Equal(t, int64(1), resp.GetSegmentInfos()[0].GetCollectionID())
+		assert.Equal(t, int64(2), resp.GetSegmentInfos()[0].GetPartitionID())
+		assert.Equal(t, "ch-1", resp.GetSegmentInfos()[0].GetVChannel())
+		assert.ElementsMatch(t, []int64{1, 5}, resp.GetSegmentInfos()[0].GetInsertLogs()[0].GetLogIDs())
+		assert.ElementsMatch(t, []int64{2, 6}, resp.GetSegmentInfos()[0].GetInsertLogs()[1].GetLogIDs())
+		assert.ElementsMatch(t, []int64{3, 7}, resp.GetSegmentInfos()[0].GetInsertLogs()[2].GetLogIDs())
+		assert.ElementsMatch(t, []int64{4, 8}, resp.GetSegmentInfos()[0].GetInsertLogs()[3].GetLogIDs())
+	})
+}

internal/proxy/proxy_test.go

@@ -1919,6 +1919,18 @@ func TestProxy(t *testing.T) {
 		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
 	})
 
+	wg.Add(1)
+	t.Run("get segment info", func(t *testing.T) {
+		defer wg.Done()
+		resp, err := proxy.GetSegmentsInfo(ctx, &internalpb.GetSegmentsInfoRequest{
+			DbName:       dbName,
+			CollectionID: 1,
+			SegmentIDs:   segmentIDs,
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
+	})
+
 	wg.Add(1)
 	t.Run("get query segment info", func(t *testing.T) {
 		defer wg.Done()

pkg/proto/internal.proto

@@ -399,3 +399,33 @@ message ListImportsResponse {
   repeated int64 progresses = 5;
   repeated string collection_names = 6;
 }
+
+message GetSegmentsInfoRequest {
+  string dbName = 1;
+  int64 collectionID = 2;
+  repeated int64 segmentIDs = 3;
+}
+
+message FieldBinlog {
+  int64 fieldID = 1;
+  repeated int64 logIDs = 2;
+}
+
+message SegmentInfo {
+  int64 segmentID = 1;
+  int64 collectionID = 2;
+  int64 partitionID = 3;
+  string vChannel = 4;
+  int64 num_rows = 5;
+  common.SegmentState state = 6;
+  common.SegmentLevel level = 7;
+  bool is_sorted = 8;
+  repeated FieldBinlog insert_logs = 9;
+  repeated FieldBinlog delta_logs = 10;
+  repeated FieldBinlog stats_logs = 11;
+}
+
+message GetSegmentsInfoResponse {
+  common.Status status = 1;
+  repeated SegmentInfo segmentInfos = 2;
+}

pkg/proto/internalpb/internal.pb.go

@@ -3549,6 +3549,306 @@ func (x *ListImportsResponse) GetCollectionNames() []string {
 	return nil
 }
 
+type GetSegmentsInfoRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DbName       string  `protobuf:"bytes,1,opt,name=dbName,proto3" json:"dbName,omitempty"`
+	CollectionID int64   `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
+	SegmentIDs   []int64 `protobuf:"varint,3,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
+}
+
+func (x *GetSegmentsInfoRequest) Reset() {
+	*x = GetSegmentsInfoRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GetSegmentsInfoRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetSegmentsInfoRequest) ProtoMessage() {}
+
+func (x *GetSegmentsInfoRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_proto_msgTypes[40]
+	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 GetSegmentsInfoRequest.ProtoReflect.Descriptor instead.
+func (*GetSegmentsInfoRequest) Descriptor() ([]byte, []int) {
+	return file_internal_proto_rawDescGZIP(), []int{40}
+}
+
+func (x *GetSegmentsInfoRequest) GetDbName() string {
+	if x != nil {
+		return x.DbName
+	}
+	return ""
+}
+
+func (x *GetSegmentsInfoRequest) GetCollectionID() int64 {
+	if x != nil {
+		return x.CollectionID
+	}
+	return 0
+}
+
+func (x *GetSegmentsInfoRequest) GetSegmentIDs() []int64 {
+	if x != nil {
+		return x.SegmentIDs
+	}
+	return nil
+}
+
+type FieldBinlog struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	FieldID int64   `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
+	LogIDs  []int64 `protobuf:"varint,2,rep,packed,name=logIDs,proto3" json:"logIDs,omitempty"`
+}
+
+func (x *FieldBinlog) Reset() {
+	*x = FieldBinlog{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldBinlog) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldBinlog) ProtoMessage() {}
+
+func (x *FieldBinlog) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_proto_msgTypes[41]
+	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 FieldBinlog.ProtoReflect.Descriptor instead.
+func (*FieldBinlog) Descriptor() ([]byte, []int) {
+	return file_internal_proto_rawDescGZIP(), []int{41}
+}
+
+func (x *FieldBinlog) GetFieldID() int64 {
+	if x != nil {
+		return x.FieldID
+	}
+	return 0
+}
+
+func (x *FieldBinlog) GetLogIDs() []int64 {
+	if x != nil {
+		return x.LogIDs
+	}
+	return nil
+}
+
+type SegmentInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SegmentID    int64                 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
+	CollectionID int64                 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
+	PartitionID  int64                 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
+	VChannel     string                `protobuf:"bytes,4,opt,name=vChannel,proto3" json:"vChannel,omitempty"`
+	NumRows      int64                 `protobuf:"varint,5,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
+	State        commonpb.SegmentState `protobuf:"varint,6,opt,name=state,proto3,enum=milvus.proto.common.SegmentState" json:"state,omitempty"`
+	Level        commonpb.SegmentLevel `protobuf:"varint,7,opt,name=level,proto3,enum=milvus.proto.common.SegmentLevel" json:"level,omitempty"`
+	IsSorted     bool                  `protobuf:"varint,8,opt,name=is_sorted,json=isSorted,proto3" json:"is_sorted,omitempty"`
+	InsertLogs   []*FieldBinlog        `protobuf:"bytes,9,rep,name=insert_logs,json=insertLogs,proto3" json:"insert_logs,omitempty"`
+	DeltaLogs    []*FieldBinlog        `protobuf:"bytes,10,rep,name=delta_logs,json=deltaLogs,proto3" json:"delta_logs,omitempty"`
+	StatsLogs    []*FieldBinlog        `protobuf:"bytes,11,rep,name=stats_logs,json=statsLogs,proto3" json:"stats_logs,omitempty"`
+}
+
+func (x *SegmentInfo) Reset() {
+	*x = SegmentInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SegmentInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SegmentInfo) ProtoMessage() {}
+
+func (x *SegmentInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_proto_msgTypes[42]
+	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 SegmentInfo.ProtoReflect.Descriptor instead.
+func (*SegmentInfo) Descriptor() ([]byte, []int) {
+	return file_internal_proto_rawDescGZIP(), []int{42}
+}
+
+func (x *SegmentInfo) GetSegmentID() int64 {
+	if x != nil {
+		return x.SegmentID
+	}
+	return 0
+}
+
+func (x *SegmentInfo) GetCollectionID() int64 {
+	if x != nil {
+		return x.CollectionID
+	}
+	return 0
+}
+
+func (x *SegmentInfo) GetPartitionID() int64 {
+	if x != nil {
+		return x.PartitionID
+	}
+	return 0
+}
+
+func (x *SegmentInfo) GetVChannel() string {
+	if x != nil {
+		return x.VChannel
+	}
+	return ""
+}
+
+func (x *SegmentInfo) GetNumRows() int64 {
+	if x != nil {
+		return x.NumRows
+	}
+	return 0
+}
+
+func (x *SegmentInfo) GetState() commonpb.SegmentState {
+	if x != nil {
+		return x.State
+	}
+	return commonpb.SegmentState(0)
+}
+
+func (x *SegmentInfo) GetLevel() commonpb.SegmentLevel {
+	if x != nil {
+		return x.Level
+	}
+	return commonpb.SegmentLevel(0)
+}
+
+func (x *SegmentInfo) GetIsSorted() bool {
+	if x != nil {
+		return x.IsSorted
+	}
+	return false
+}
+
+func (x *SegmentInfo) GetInsertLogs() []*FieldBinlog {
+	if x != nil {
+		return x.InsertLogs
+	}
+	return nil
+}
+
+func (x *SegmentInfo) GetDeltaLogs() []*FieldBinlog {
+	if x != nil {
+		return x.DeltaLogs
+	}
+	return nil
+}
+
+func (x *SegmentInfo) GetStatsLogs() []*FieldBinlog {
+	if x != nil {
+		return x.StatsLogs
+	}
+	return nil
+}
+
+type GetSegmentsInfoResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Status       *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	SegmentInfos []*SegmentInfo   `protobuf:"bytes,2,rep,name=segmentInfos,proto3" json:"segmentInfos,omitempty"`
+}
+
+func (x *GetSegmentsInfoResponse) Reset() {
+	*x = GetSegmentsInfoResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GetSegmentsInfoResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetSegmentsInfoResponse) ProtoMessage() {}
+
+func (x *GetSegmentsInfoResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_proto_msgTypes[43]
+	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 GetSegmentsInfoResponse.ProtoReflect.Descriptor instead.
+func (*GetSegmentsInfoResponse) Descriptor() ([]byte, []int) {
+	return file_internal_proto_rawDescGZIP(), []int{43}
+}
+
+func (x *GetSegmentsInfoResponse) GetStatus() *commonpb.Status {
+	if x != nil {
+		return x.Status
+	}
+	return nil
+}
+
+func (x *GetSegmentsInfoResponse) GetSegmentInfos() []*SegmentInfo {
+	if x != nil {
+		return x.SegmentInfos
+	}
+	return nil
+}
+
 var File_internal_proto protoreflect.FileDescriptor
 
 var file_internal_proto_rawDesc = []byte{
@@ -4164,35 +4464,88 @@ var file_internal_proto_rawDesc = []byte{
 	0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
 	0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52,
 	0x0f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73,
-	0x2a, 0x45, 0x0a, 0x09, 0x52, 0x61, 0x74, 0x65, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x0b, 0x0a,
+	0x22, 0x74, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49,
-	0x07, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x61,
+	0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x62,
-	0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x43, 0x6f, 0x6c, 0x6c,
+	0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x62, 0x4e, 0x61,
-	0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x50, 0x61, 0x72, 0x74,
+	0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x03, 0x2a, 0xb9, 0x01, 0x0a, 0x08, 0x52, 0x61, 0x74, 0x65,
+	0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
-	0x54, 0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x44, 0x4c, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
+	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e,
-	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x44, 0x44, 0x4c, 0x50, 0x61,
+	0x74, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d,
-	0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x44, 0x4c,
+	0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x22, 0x3f, 0x0a, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42,
-	0x49, 0x6e, 0x64, 0x65, 0x78, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x44, 0x4c, 0x46, 0x6c,
+	0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44,
-	0x75, 0x73, 0x68, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x44, 0x4c, 0x43, 0x6f, 0x6d, 0x70,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44, 0x12,
-	0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x04, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x4d, 0x4c, 0x49,
+	0x16, 0x0a, 0x06, 0x6c, 0x6f, 0x67, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52,
-	0x6e, 0x73, 0x65, 0x72, 0x74, 0x10, 0x05, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x4d, 0x4c, 0x44, 0x65,
+	0x06, 0x6c, 0x6f, 0x67, 0x49, 0x44, 0x73, 0x22, 0x82, 0x04, 0x0a, 0x0b, 0x53, 0x65, 0x67, 0x6d,
-	0x6c, 0x65, 0x74, 0x65, 0x10, 0x06, 0x12, 0x0f, 0x0a, 0x0b, 0x44, 0x4d, 0x4c, 0x42, 0x75, 0x6c,
+	0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65,
-	0x6b, 0x4c, 0x6f, 0x61, 0x64, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x51, 0x4c, 0x53, 0x65,
+	0x6e, 0x74, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d,
-	0x61, 0x72, 0x63, 0x68, 0x10, 0x08, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x51, 0x4c, 0x51, 0x75, 0x65,
+	0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
-	0x72, 0x79, 0x10, 0x09, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x4d, 0x4c, 0x55, 0x70, 0x73, 0x65, 0x72,
+	0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c,
-	0x74, 0x10, 0x0a, 0x2a, 0x81, 0x01, 0x0a, 0x0e, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4a, 0x6f,
+	0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72,
-	0x62, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x6f, 0x6e, 0x65, 0x10, 0x00,
+	0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b,
-	0x12, 0x0b, 0x0a, 0x07, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x10, 0x01, 0x12, 0x10, 0x0a,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x76,
-	0x0c, 0x50, 0x72, 0x65, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x10, 0x02, 0x12,
+	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76,
-	0x0d, 0x0a, 0x09, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x10, 0x03, 0x12, 0x0a,
+	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x75, 0x6d, 0x5f, 0x72,
-	0x0a, 0x06, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0x04, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x6f,
+	0x6f, 0x77, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x75, 0x6d, 0x52, 0x6f,
-	0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x6e, 0x64,
+	0x77, 0x73, 0x12, 0x37, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
-	0x65, 0x78, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x10, 0x06, 0x12, 0x09, 0x0a, 0x05,
+	0x0e, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x10, 0x07, 0x42, 0x35, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75,
+	0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53,
-	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f,
+	0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x05, 0x6c,
-	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72,
+	0x65, 0x76, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c,
-	0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x70, 0x62, 0x62, 0x06,
+	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x6c,
+	0x65, 0x76, 0x65, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x65,
+	0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65,
+	0x64, 0x12, 0x43, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x5f, 0x6c, 0x6f, 0x67, 0x73,
+	0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x46,
+	0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x65,
+	0x72, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x41, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x5f,
+	0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
+	0x61, 0x6c, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x09,
+	0x64, 0x65, 0x6c, 0x74, 0x61, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x41, 0x0a, 0x0a, 0x73, 0x74, 0x61,
+	0x74, 0x73, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f,
+	0x67, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x22, 0x96, 0x01, 0x0a,
+	0x17, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f,
+	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, 0x46, 0x0a,
+	0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x67, 0x6d,
+	0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+	0x49, 0x6e, 0x66, 0x6f, 0x73, 0x2a, 0x45, 0x0a, 0x09, 0x52, 0x61, 0x74, 0x65, 0x53, 0x63, 0x6f,
+	0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x10, 0x00, 0x12,
+	0x0c, 0x0a, 0x08, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x10, 0x01, 0x12, 0x0e, 0x0a,
+	0x0a, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x02, 0x12, 0x0d, 0x0a,
+	0x09, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x03, 0x2a, 0xb9, 0x01, 0x0a,
+	0x08, 0x52, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x44, 0x4c,
+	0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c,
+	0x44, 0x44, 0x4c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x01, 0x12, 0x0c,
+	0x0a, 0x08, 0x44, 0x44, 0x4c, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08,
+	0x44, 0x44, 0x4c, 0x46, 0x6c, 0x75, 0x73, 0x68, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x44,
+	0x4c, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x04, 0x12, 0x0d, 0x0a,
+	0x09, 0x44, 0x4d, 0x4c, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x10, 0x05, 0x12, 0x0d, 0x0a, 0x09,
+	0x44, 0x4d, 0x4c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x10, 0x06, 0x12, 0x0f, 0x0a, 0x0b, 0x44,
+	0x4d, 0x4c, 0x42, 0x75, 0x6c, 0x6b, 0x4c, 0x6f, 0x61, 0x64, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09,
+	0x44, 0x51, 0x4c, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x10, 0x08, 0x12, 0x0c, 0x0a, 0x08, 0x44,
+	0x51, 0x4c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x10, 0x09, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x4d, 0x4c,
+	0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x10, 0x0a, 0x2a, 0x81, 0x01, 0x0a, 0x0e, 0x49, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x4e,
+	0x6f, 0x6e, 0x65, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+	0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x72, 0x65, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x69,
+	0x6e, 0x67, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e,
+	0x67, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0x04, 0x12,
+	0x0d, 0x0a, 0x09, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x10, 0x05, 0x12, 0x11,
+	0x0a, 0x0d, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x10,
+	0x06, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x74, 0x61, 0x74, 0x73, 0x10, 0x07, 0x42, 0x35, 0x5a, 0x33,
+	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, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
+	0x6c, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -4208,7 +4561,7 @@ func file_internal_proto_rawDescGZIP() []byte {
 }
 
 var file_internal_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
-var file_internal_proto_msgTypes = make([]protoimpl.MessageInfo, 41)
+var file_internal_proto_msgTypes = make([]protoimpl.MessageInfo, 45)
 var file_internal_proto_goTypes = []interface{}{
 	(RateScope)(0),                      // 0: milvus.proto.internal.RateScope
 	(RateType)(0),                       // 1: milvus.proto.internal.RateType
@@ -4253,76 +4606,89 @@ var file_internal_proto_goTypes = []interface{}{
 	(*ListImportsRequestInternal)(nil),  // 40: milvus.proto.internal.ListImportsRequestInternal
 	(*ListImportsRequest)(nil),          // 41: milvus.proto.internal.ListImportsRequest
 	(*ListImportsResponse)(nil),         // 42: milvus.proto.internal.ListImportsResponse
-	nil,                                 // 43: milvus.proto.internal.SearchResults.ChannelsMvccEntry
+	(*GetSegmentsInfoRequest)(nil),      // 43: milvus.proto.internal.GetSegmentsInfoRequest
-	(*commonpb.Address)(nil),            // 44: milvus.proto.common.Address
+	(*FieldBinlog)(nil),                 // 44: milvus.proto.internal.FieldBinlog
-	(*commonpb.KeyValuePair)(nil),       // 45: milvus.proto.common.KeyValuePair
+	(*SegmentInfo)(nil),                 // 45: milvus.proto.internal.SegmentInfo
-	(*commonpb.Status)(nil),             // 46: milvus.proto.common.Status
+	(*GetSegmentsInfoResponse)(nil),     // 46: milvus.proto.internal.GetSegmentsInfoResponse
-	(*commonpb.MsgBase)(nil),            // 47: milvus.proto.common.MsgBase
+	nil,                                 // 47: milvus.proto.internal.SearchResults.ChannelsMvccEntry
-	(commonpb.DslType)(0),               // 48: milvus.proto.common.DslType
+	(*commonpb.Address)(nil),            // 48: milvus.proto.common.Address
-	(commonpb.ConsistencyLevel)(0),      // 49: milvus.proto.common.ConsistencyLevel
+	(*commonpb.KeyValuePair)(nil),       // 49: milvus.proto.common.KeyValuePair
-	(*schemapb.IDs)(nil),                // 50: milvus.proto.schema.IDs
+	(*commonpb.Status)(nil),             // 50: milvus.proto.common.Status
-	(*schemapb.FieldData)(nil),          // 51: milvus.proto.schema.FieldData
+	(*commonpb.MsgBase)(nil),            // 51: milvus.proto.common.MsgBase
-	(*milvuspb.PrivilegeGroupInfo)(nil), // 52: milvus.proto.milvus.PrivilegeGroupInfo
+	(commonpb.DslType)(0),               // 52: milvus.proto.common.DslType
-	(*schemapb.CollectionSchema)(nil),   // 53: milvus.proto.schema.CollectionSchema
+	(commonpb.ConsistencyLevel)(0),      // 53: milvus.proto.common.ConsistencyLevel
+	(*schemapb.IDs)(nil),                // 54: milvus.proto.schema.IDs
+	(*schemapb.FieldData)(nil),          // 55: milvus.proto.schema.FieldData
+	(*milvuspb.PrivilegeGroupInfo)(nil), // 56: milvus.proto.milvus.PrivilegeGroupInfo
+	(*schemapb.CollectionSchema)(nil),   // 57: milvus.proto.schema.CollectionSchema
+	(commonpb.SegmentState)(0),          // 58: milvus.proto.common.SegmentState
+	(commonpb.SegmentLevel)(0),          // 59: milvus.proto.common.SegmentLevel
 }
 var file_internal_proto_depIdxs = []int32{
-	44, // 0: milvus.proto.internal.NodeInfo.address:type_name -> milvus.proto.common.Address
+	48, // 0: milvus.proto.internal.NodeInfo.address:type_name -> milvus.proto.common.Address
-	45, // 1: milvus.proto.internal.InitParams.start_params:type_name -> milvus.proto.common.KeyValuePair
+	49, // 1: milvus.proto.internal.InitParams.start_params:type_name -> milvus.proto.common.KeyValuePair
-	46, // 2: milvus.proto.internal.StringList.status:type_name -> milvus.proto.common.Status
+	50, // 2: milvus.proto.internal.StringList.status:type_name -> milvus.proto.common.Status
-	47, // 3: milvus.proto.internal.GetStatisticsRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 3: milvus.proto.internal.GetStatisticsRequest.base:type_name -> milvus.proto.common.MsgBase
-	47, // 4: milvus.proto.internal.GetStatisticsResponse.base:type_name -> milvus.proto.common.MsgBase
+	51, // 4: milvus.proto.internal.GetStatisticsResponse.base:type_name -> milvus.proto.common.MsgBase
-	46, // 5: milvus.proto.internal.GetStatisticsResponse.status:type_name -> milvus.proto.common.Status
+	50, // 5: milvus.proto.internal.GetStatisticsResponse.status:type_name -> milvus.proto.common.Status
-	45, // 6: milvus.proto.internal.GetStatisticsResponse.stats:type_name -> milvus.proto.common.KeyValuePair
+	49, // 6: milvus.proto.internal.GetStatisticsResponse.stats:type_name -> milvus.proto.common.KeyValuePair
-	47, // 7: milvus.proto.internal.CreateAliasRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 7: milvus.proto.internal.CreateAliasRequest.base:type_name -> milvus.proto.common.MsgBase
-	47, // 8: milvus.proto.internal.DropAliasRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 8: milvus.proto.internal.DropAliasRequest.base:type_name -> milvus.proto.common.MsgBase
-	47, // 9: milvus.proto.internal.AlterAliasRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 9: milvus.proto.internal.AlterAliasRequest.base:type_name -> milvus.proto.common.MsgBase
-	47, // 10: milvus.proto.internal.CreateIndexRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 10: milvus.proto.internal.CreateIndexRequest.base:type_name -> milvus.proto.common.MsgBase
-	45, // 11: milvus.proto.internal.CreateIndexRequest.extra_params:type_name -> milvus.proto.common.KeyValuePair
+	49, // 11: milvus.proto.internal.CreateIndexRequest.extra_params:type_name -> milvus.proto.common.KeyValuePair
-	48, // 12: milvus.proto.internal.SubSearchRequest.dsl_type:type_name -> milvus.proto.common.DslType
+	52, // 12: milvus.proto.internal.SubSearchRequest.dsl_type:type_name -> milvus.proto.common.DslType
-	47, // 13: milvus.proto.internal.SearchRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 13: milvus.proto.internal.SearchRequest.base:type_name -> milvus.proto.common.MsgBase
-	48, // 14: milvus.proto.internal.SearchRequest.dsl_type:type_name -> milvus.proto.common.DslType
+	52, // 14: milvus.proto.internal.SearchRequest.dsl_type:type_name -> milvus.proto.common.DslType
 	15, // 15: milvus.proto.internal.SearchRequest.sub_reqs:type_name -> milvus.proto.internal.SubSearchRequest
-	49, // 16: milvus.proto.internal.SearchRequest.consistency_level:type_name -> milvus.proto.common.ConsistencyLevel
+	53, // 16: milvus.proto.internal.SearchRequest.consistency_level:type_name -> milvus.proto.common.ConsistencyLevel
-	47, // 17: milvus.proto.internal.SearchResults.base:type_name -> milvus.proto.common.MsgBase
+	51, // 17: milvus.proto.internal.SearchResults.base:type_name -> milvus.proto.common.MsgBase
-	46, // 18: milvus.proto.internal.SearchResults.status:type_name -> milvus.proto.common.Status
+	50, // 18: milvus.proto.internal.SearchResults.status:type_name -> milvus.proto.common.Status
 	19, // 19: milvus.proto.internal.SearchResults.costAggregation:type_name -> milvus.proto.internal.CostAggregation
-	43, // 20: milvus.proto.internal.SearchResults.channels_mvcc:type_name -> milvus.proto.internal.SearchResults.ChannelsMvccEntry
+	47, // 20: milvus.proto.internal.SearchResults.channels_mvcc:type_name -> milvus.proto.internal.SearchResults.ChannelsMvccEntry
 	17, // 21: milvus.proto.internal.SearchResults.sub_results:type_name -> milvus.proto.internal.SubSearchResults
-	47, // 22: milvus.proto.internal.RetrieveRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 22: milvus.proto.internal.RetrieveRequest.base:type_name -> milvus.proto.common.MsgBase
-	49, // 23: milvus.proto.internal.RetrieveRequest.consistency_level:type_name -> milvus.proto.common.ConsistencyLevel
+	53, // 23: milvus.proto.internal.RetrieveRequest.consistency_level:type_name -> milvus.proto.common.ConsistencyLevel
-	47, // 24: milvus.proto.internal.RetrieveResults.base:type_name -> milvus.proto.common.MsgBase
+	51, // 24: milvus.proto.internal.RetrieveResults.base:type_name -> milvus.proto.common.MsgBase
-	46, // 25: milvus.proto.internal.RetrieveResults.status:type_name -> milvus.proto.common.Status
+	50, // 25: milvus.proto.internal.RetrieveResults.status:type_name -> milvus.proto.common.Status
-	50, // 26: milvus.proto.internal.RetrieveResults.ids:type_name -> milvus.proto.schema.IDs
+	54, // 26: milvus.proto.internal.RetrieveResults.ids:type_name -> milvus.proto.schema.IDs
-	51, // 27: milvus.proto.internal.RetrieveResults.fields_data:type_name -> milvus.proto.schema.FieldData
+	55, // 27: milvus.proto.internal.RetrieveResults.fields_data:type_name -> milvus.proto.schema.FieldData
 	19, // 28: milvus.proto.internal.RetrieveResults.costAggregation:type_name -> milvus.proto.internal.CostAggregation
-	47, // 29: milvus.proto.internal.LoadIndex.base:type_name -> milvus.proto.common.MsgBase
+	51, // 29: milvus.proto.internal.LoadIndex.base:type_name -> milvus.proto.common.MsgBase
-	45, // 30: milvus.proto.internal.LoadIndex.index_params:type_name -> milvus.proto.common.KeyValuePair
+	49, // 30: milvus.proto.internal.LoadIndex.index_params:type_name -> milvus.proto.common.KeyValuePair
-	45, // 31: milvus.proto.internal.IndexStats.index_params:type_name -> milvus.proto.common.KeyValuePair
+	49, // 31: milvus.proto.internal.IndexStats.index_params:type_name -> milvus.proto.common.KeyValuePair
 	23, // 32: milvus.proto.internal.FieldStats.index_stats:type_name -> milvus.proto.internal.IndexStats
-	47, // 33: milvus.proto.internal.ChannelTimeTickMsg.base:type_name -> milvus.proto.common.MsgBase
+	51, // 33: milvus.proto.internal.ChannelTimeTickMsg.base:type_name -> milvus.proto.common.MsgBase
-	47, // 34: milvus.proto.internal.ListPolicyRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 34: milvus.proto.internal.ListPolicyRequest.base:type_name -> milvus.proto.common.MsgBase
-	46, // 35: milvus.proto.internal.ListPolicyResponse.status:type_name -> milvus.proto.common.Status
+	50, // 35: milvus.proto.internal.ListPolicyResponse.status:type_name -> milvus.proto.common.Status
-	52, // 36: milvus.proto.internal.ListPolicyResponse.privilege_groups:type_name -> milvus.proto.milvus.PrivilegeGroupInfo
+	56, // 36: milvus.proto.internal.ListPolicyResponse.privilege_groups:type_name -> milvus.proto.milvus.PrivilegeGroupInfo
-	47, // 37: milvus.proto.internal.ShowConfigurationsRequest.base:type_name -> milvus.proto.common.MsgBase
+	51, // 37: milvus.proto.internal.ShowConfigurationsRequest.base:type_name -> milvus.proto.common.MsgBase
-	46, // 38: milvus.proto.internal.ShowConfigurationsResponse.status:type_name -> milvus.proto.common.Status
+	50, // 38: milvus.proto.internal.ShowConfigurationsResponse.status:type_name -> milvus.proto.common.Status
-	45, // 39: milvus.proto.internal.ShowConfigurationsResponse.configuations:type_name -> milvus.proto.common.KeyValuePair
+	49, // 39: milvus.proto.internal.ShowConfigurationsResponse.configuations:type_name -> milvus.proto.common.KeyValuePair
 	1,  // 40: milvus.proto.internal.Rate.rt:type_name -> milvus.proto.internal.RateType
-	53, // 41: milvus.proto.internal.ImportRequestInternal.schema:type_name -> milvus.proto.schema.CollectionSchema
+	57, // 41: milvus.proto.internal.ImportRequestInternal.schema:type_name -> milvus.proto.schema.CollectionSchema
 	33, // 42: milvus.proto.internal.ImportRequestInternal.files:type_name -> milvus.proto.internal.ImportFile
-	45, // 43: milvus.proto.internal.ImportRequestInternal.options:type_name -> milvus.proto.common.KeyValuePair
+	49, // 43: milvus.proto.internal.ImportRequestInternal.options:type_name -> milvus.proto.common.KeyValuePair
 	33, // 44: milvus.proto.internal.ImportRequest.files:type_name -> milvus.proto.internal.ImportFile
-	45, // 45: milvus.proto.internal.ImportRequest.options:type_name -> milvus.proto.common.KeyValuePair
+	49, // 45: milvus.proto.internal.ImportRequest.options:type_name -> milvus.proto.common.KeyValuePair
-	46, // 46: milvus.proto.internal.ImportResponse.status:type_name -> milvus.proto.common.Status
+	50, // 46: milvus.proto.internal.ImportResponse.status:type_name -> milvus.proto.common.Status
-	46, // 47: milvus.proto.internal.GetImportProgressResponse.status:type_name -> milvus.proto.common.Status
+	50, // 47: milvus.proto.internal.GetImportProgressResponse.status:type_name -> milvus.proto.common.Status
 	2,  // 48: milvus.proto.internal.GetImportProgressResponse.state:type_name -> milvus.proto.internal.ImportJobState
 	38, // 49: milvus.proto.internal.GetImportProgressResponse.task_progresses:type_name -> milvus.proto.internal.ImportTaskProgress
-	46, // 50: milvus.proto.internal.ListImportsResponse.status:type_name -> milvus.proto.common.Status
+	50, // 50: milvus.proto.internal.ListImportsResponse.status:type_name -> milvus.proto.common.Status
 	2,  // 51: milvus.proto.internal.ListImportsResponse.states:type_name -> milvus.proto.internal.ImportJobState
-	52, // [52:52] is the sub-list for method output_type
+	58, // 52: milvus.proto.internal.SegmentInfo.state:type_name -> milvus.proto.common.SegmentState
-	52, // [52:52] is the sub-list for method input_type
+	59, // 53: milvus.proto.internal.SegmentInfo.level:type_name -> milvus.proto.common.SegmentLevel
-	52, // [52:52] is the sub-list for extension type_name
+	44, // 54: milvus.proto.internal.SegmentInfo.insert_logs:type_name -> milvus.proto.internal.FieldBinlog
-	52, // [52:52] is the sub-list for extension extendee
+	44, // 55: milvus.proto.internal.SegmentInfo.delta_logs:type_name -> milvus.proto.internal.FieldBinlog
-	0,  // [0:52] is the sub-list for field type_name
+	44, // 56: milvus.proto.internal.SegmentInfo.stats_logs:type_name -> milvus.proto.internal.FieldBinlog
+	50, // 57: milvus.proto.internal.GetSegmentsInfoResponse.status:type_name -> milvus.proto.common.Status
+	45, // 58: milvus.proto.internal.GetSegmentsInfoResponse.segmentInfos:type_name -> milvus.proto.internal.SegmentInfo
+	59, // [59:59] is the sub-list for method output_type
+	59, // [59:59] is the sub-list for method input_type
+	59, // [59:59] is the sub-list for extension type_name
+	59, // [59:59] is the sub-list for extension extendee
+	0,  // [0:59] is the sub-list for field type_name
 }
 
 func init() { file_internal_proto_init() }
@@ -4811,6 +5177,54 @@ func file_internal_proto_init() {
 				return nil
 			}
 		}
+		file_internal_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetSegmentsInfoRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldBinlog); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SegmentInfo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetSegmentsInfoResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -4818,7 +5232,7 @@ func file_internal_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_internal_proto_rawDesc,
 			NumEnums:      3,
-			NumMessages:   41,
+			NumMessages:   45,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

pkg/proto/proxy.proto

@@ -29,6 +29,8 @@ service Proxy {
   rpc ListImports(internal.ListImportsRequest) returns(internal.ListImportsResponse){}
   
   rpc InvalidateShardLeaderCache(InvalidateShardLeaderCacheRequest) returns (common.Status) {}
+
+  rpc GetSegmentsInfo(internal.GetSegmentsInfoRequest) returns (internal.GetSegmentsInfoResponse) {}
 }
 
 message InvalidateCollMetaCacheRequest {

pkg/proto/proxypb/proxy.pb.go

@@ -822,7 +822,7 @@ var file_proxy_proto_rawDesc = []byte{
 	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
 	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c,
 	0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74,
-	0x49, 0x6e, 0x66, 0x6f, 0x73, 0x32, 0xd0, 0x0b, 0x0a, 0x05, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x12,
+	0x49, 0x6e, 0x66, 0x6f, 0x73, 0x32, 0xc4, 0x0c, 0x0a, 0x05, 0x50, 0x72, 0x6f, 0x78, 0x79, 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,
@@ -915,11 +915,18 @@ var file_proxy_proto_rawDesc = []byte{
 	0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x43, 0x61, 0x63,
 	0x68, 0x65, 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,
+	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53,
-	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f,
+	0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x2e, 0x6d, 0x69,
-	0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72,
-	0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72,
+	0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49,
-	0x6f, 0x74, 0x6f, 0x33,
+	0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
+	0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e,
+	0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 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, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x70, 0x62,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -961,12 +968,14 @@ var file_proxy_proto_goTypes = []interface{}{
 	(*internalpb.ImportRequest)(nil),               // 22: milvus.proto.internal.ImportRequest
 	(*internalpb.GetImportProgressRequest)(nil),    // 23: milvus.proto.internal.GetImportProgressRequest
 	(*internalpb.ListImportsRequest)(nil),          // 24: milvus.proto.internal.ListImportsRequest
-	(*milvuspb.ComponentStates)(nil),               // 25: milvus.proto.milvus.ComponentStates
+	(*internalpb.GetSegmentsInfoRequest)(nil),      // 25: milvus.proto.internal.GetSegmentsInfoRequest
-	(*milvuspb.StringResponse)(nil),                // 26: milvus.proto.milvus.StringResponse
+	(*milvuspb.ComponentStates)(nil),               // 26: milvus.proto.milvus.ComponentStates
-	(*milvuspb.GetMetricsResponse)(nil),            // 27: milvus.proto.milvus.GetMetricsResponse
+	(*milvuspb.StringResponse)(nil),                // 27: milvus.proto.milvus.StringResponse
-	(*internalpb.ImportResponse)(nil),              // 28: milvus.proto.internal.ImportResponse
+	(*milvuspb.GetMetricsResponse)(nil),            // 28: milvus.proto.milvus.GetMetricsResponse
-	(*internalpb.GetImportProgressResponse)(nil),   // 29: milvus.proto.internal.GetImportProgressResponse
+	(*internalpb.ImportResponse)(nil),              // 29: milvus.proto.internal.ImportResponse
-	(*internalpb.ListImportsResponse)(nil),         // 30: milvus.proto.internal.ListImportsResponse
+	(*internalpb.GetImportProgressResponse)(nil),   // 30: milvus.proto.internal.GetImportProgressResponse
+	(*internalpb.ListImportsResponse)(nil),         // 31: milvus.proto.internal.ListImportsResponse
+	(*internalpb.GetSegmentsInfoResponse)(nil),     // 32: milvus.proto.internal.GetSegmentsInfoResponse
 }
 var file_proxy_proto_depIdxs = []int32{
 	12, // 0: milvus.proto.proxy.InvalidateCollMetaCacheRequest.base:type_name -> milvus.proto.common.MsgBase
@@ -1003,22 +1012,24 @@ var file_proxy_proto_depIdxs = []int32{
 	23, // 31: milvus.proto.proxy.Proxy.GetImportProgress:input_type -> milvus.proto.internal.GetImportProgressRequest
 	24, // 32: milvus.proto.proxy.Proxy.ListImports:input_type -> milvus.proto.internal.ListImportsRequest
 	1,  // 33: milvus.proto.proxy.Proxy.InvalidateShardLeaderCache:input_type -> milvus.proto.proxy.InvalidateShardLeaderCacheRequest
-	25, // 34: milvus.proto.proxy.Proxy.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates
+	25, // 34: milvus.proto.proxy.Proxy.GetSegmentsInfo:input_type -> milvus.proto.internal.GetSegmentsInfoRequest
-	26, // 35: milvus.proto.proxy.Proxy.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse
+	26, // 35: milvus.proto.proxy.Proxy.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates
-	16, // 36: milvus.proto.proxy.Proxy.InvalidateCollectionMetaCache:output_type -> milvus.proto.common.Status
+	27, // 36: milvus.proto.proxy.Proxy.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse
-	26, // 37: milvus.proto.proxy.Proxy.GetDdChannel:output_type -> milvus.proto.milvus.StringResponse
+	16, // 37: milvus.proto.proxy.Proxy.InvalidateCollectionMetaCache:output_type -> milvus.proto.common.Status
-	16, // 38: milvus.proto.proxy.Proxy.InvalidateCredentialCache:output_type -> milvus.proto.common.Status
+	27, // 38: milvus.proto.proxy.Proxy.GetDdChannel:output_type -> milvus.proto.milvus.StringResponse
-	16, // 39: milvus.proto.proxy.Proxy.UpdateCredentialCache:output_type -> milvus.proto.common.Status
+	16, // 39: milvus.proto.proxy.Proxy.InvalidateCredentialCache:output_type -> milvus.proto.common.Status
-	16, // 40: milvus.proto.proxy.Proxy.RefreshPolicyInfoCache:output_type -> milvus.proto.common.Status
+	16, // 40: milvus.proto.proxy.Proxy.UpdateCredentialCache:output_type -> milvus.proto.common.Status
-	27, // 41: milvus.proto.proxy.Proxy.GetProxyMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse
+	16, // 41: milvus.proto.proxy.Proxy.RefreshPolicyInfoCache:output_type -> milvus.proto.common.Status
-	16, // 42: milvus.proto.proxy.Proxy.SetRates:output_type -> milvus.proto.common.Status
+	28, // 42: milvus.proto.proxy.Proxy.GetProxyMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse
-	10, // 43: milvus.proto.proxy.Proxy.ListClientInfos:output_type -> milvus.proto.proxy.ListClientInfosResponse
+	16, // 43: milvus.proto.proxy.Proxy.SetRates:output_type -> milvus.proto.common.Status
-	28, // 44: milvus.proto.proxy.Proxy.ImportV2:output_type -> milvus.proto.internal.ImportResponse
+	10, // 44: milvus.proto.proxy.Proxy.ListClientInfos:output_type -> milvus.proto.proxy.ListClientInfosResponse
-	29, // 45: milvus.proto.proxy.Proxy.GetImportProgress:output_type -> milvus.proto.internal.GetImportProgressResponse
+	29, // 45: milvus.proto.proxy.Proxy.ImportV2:output_type -> milvus.proto.internal.ImportResponse
-	30, // 46: milvus.proto.proxy.Proxy.ListImports:output_type -> milvus.proto.internal.ListImportsResponse
+	30, // 46: milvus.proto.proxy.Proxy.GetImportProgress:output_type -> milvus.proto.internal.GetImportProgressResponse
-	16, // 47: milvus.proto.proxy.Proxy.InvalidateShardLeaderCache:output_type -> milvus.proto.common.Status
+	31, // 47: milvus.proto.proxy.Proxy.ListImports:output_type -> milvus.proto.internal.ListImportsResponse
-	34, // [34:48] is the sub-list for method output_type
+	16, // 48: milvus.proto.proxy.Proxy.InvalidateShardLeaderCache:output_type -> milvus.proto.common.Status
-	20, // [20:34] is the sub-list for method input_type
+	32, // 49: milvus.proto.proxy.Proxy.GetSegmentsInfo:output_type -> milvus.proto.internal.GetSegmentsInfoResponse
+	35, // [35:50] is the sub-list for method output_type
+	20, // [20:35] is the sub-list for method input_type
 	20, // [20:20] is the sub-list for extension type_name
 	20, // [20:20] is the sub-list for extension extendee
 	0,  // [0:20] is the sub-list for field type_name

pkg/proto/proxypb/proxy_grpc.pb.go

@@ -36,6 +36,7 @@ const (
 	Proxy_GetImportProgress_FullMethodName             = "/milvus.proto.proxy.Proxy/GetImportProgress"
 	Proxy_ListImports_FullMethodName                   = "/milvus.proto.proxy.Proxy/ListImports"
 	Proxy_InvalidateShardLeaderCache_FullMethodName    = "/milvus.proto.proxy.Proxy/InvalidateShardLeaderCache"
+	Proxy_GetSegmentsInfo_FullMethodName               = "/milvus.proto.proxy.Proxy/GetSegmentsInfo"
 )
 
 // ProxyClient is the client API for Proxy service.
@@ -57,6 +58,7 @@ type ProxyClient interface {
 	GetImportProgress(ctx context.Context, in *internalpb.GetImportProgressRequest, opts ...grpc.CallOption) (*internalpb.GetImportProgressResponse, error)
 	ListImports(ctx context.Context, in *internalpb.ListImportsRequest, opts ...grpc.CallOption) (*internalpb.ListImportsResponse, error)
 	InvalidateShardLeaderCache(ctx context.Context, in *InvalidateShardLeaderCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	GetSegmentsInfo(ctx context.Context, in *internalpb.GetSegmentsInfoRequest, opts ...grpc.CallOption) (*internalpb.GetSegmentsInfoResponse, error)
 }
 
 type proxyClient struct {
@@ -193,6 +195,15 @@ func (c *proxyClient) InvalidateShardLeaderCache(ctx context.Context, in *Invali
 	return out, nil
 }
 
+func (c *proxyClient) GetSegmentsInfo(ctx context.Context, in *internalpb.GetSegmentsInfoRequest, opts ...grpc.CallOption) (*internalpb.GetSegmentsInfoResponse, error) {
+	out := new(internalpb.GetSegmentsInfoResponse)
+	err := c.cc.Invoke(ctx, Proxy_GetSegmentsInfo_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ProxyServer is the server API for Proxy service.
 // All implementations should embed UnimplementedProxyServer
 // for forward compatibility
@@ -212,6 +223,7 @@ type ProxyServer interface {
 	GetImportProgress(context.Context, *internalpb.GetImportProgressRequest) (*internalpb.GetImportProgressResponse, error)
 	ListImports(context.Context, *internalpb.ListImportsRequest) (*internalpb.ListImportsResponse, error)
 	InvalidateShardLeaderCache(context.Context, *InvalidateShardLeaderCacheRequest) (*commonpb.Status, error)
+	GetSegmentsInfo(context.Context, *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error)
 }
 
 // UnimplementedProxyServer should be embedded to have forward compatible implementations.
@@ -260,6 +272,9 @@ func (UnimplementedProxyServer) ListImports(context.Context, *internalpb.ListImp
 func (UnimplementedProxyServer) InvalidateShardLeaderCache(context.Context, *InvalidateShardLeaderCacheRequest) (*commonpb.Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method InvalidateShardLeaderCache not implemented")
 }
+func (UnimplementedProxyServer) GetSegmentsInfo(context.Context, *internalpb.GetSegmentsInfoRequest) (*internalpb.GetSegmentsInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetSegmentsInfo not implemented")
+}
 
 // UnsafeProxyServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to ProxyServer will
@@ -524,6 +539,24 @@ func _Proxy_InvalidateShardLeaderCache_Handler(srv interface{}, ctx context.Cont
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Proxy_GetSegmentsInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(internalpb.GetSegmentsInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ProxyServer).GetSegmentsInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Proxy_GetSegmentsInfo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ProxyServer).GetSegmentsInfo(ctx, req.(*internalpb.GetSegmentsInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Proxy_ServiceDesc is the grpc.ServiceDesc for Proxy service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -587,6 +620,10 @@ var Proxy_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "InvalidateShardLeaderCache",
 			Handler:    _Proxy_InvalidateShardLeaderCache_Handler,
 		},
+		{
+			MethodName: "GetSegmentsInfo",
+			Handler:    _Proxy_GetSegmentsInfo_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "proxy.proto",