feat: Support add_function/alter_function/drop_function (#44895)

https://github.com/milvus-io/milvus/issues/44053

Signed-off-by: junjie.jiang <junjie.jiang@zilliz.com>

internal/coordinator/mix_coord.go

@@ -463,6 +463,18 @@ func (s *mixCoordImpl) AlterCollectionField(ctx context.Context, req *milvuspb.A
 	return s.rootcoordServer.AlterCollectionField(ctx, req)
 }
 
+func (s *mixCoordImpl) AddCollectionFunction(ctx context.Context, req *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.rootcoordServer.AddCollectionFunction(ctx, req)
+}
+
+func (s *mixCoordImpl) AlterCollectionFunction(ctx context.Context, req *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.rootcoordServer.AlterCollectionFunction(ctx, req)
+}
+
+func (s *mixCoordImpl) DropCollectionFunction(ctx context.Context, req *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.rootcoordServer.DropCollectionFunction(ctx, req)
+}
+
 func (s *mixCoordImpl) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
 	return s.rootcoordServer.CreatePartition(ctx, req)
 }

internal/datacoord/mock_handler.go

@@ -413,8 +413,7 @@ func (_c *NMockHandler_ListLoadedSegments_Call) RunAndReturn(run func(context.Co
 func NewNMockHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-},
-) *NMockHandler {
+}) *NMockHandler {
 	mock := &NMockHandler{}
 	mock.Mock.Test(t)
 

internal/datacoord/mock_test.go

@@ -323,6 +323,18 @@ func (m *mockMixCoord) AlterCollectionField(ctx context.Context, request *milvus
 	panic("not implemented") // TODO: Implement
 }
 
+func (m *mockMixCoord) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	panic("not implemented") // TODO: Implement
+}
+
+func (m *mockMixCoord) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	panic("not implemented") // TODO: Implement
+}
+
+func (m *mockMixCoord) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	panic("not implemented") // TODO: Implement
+}
+
 func (m *mockMixCoord) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
 	panic("not implemented") // TODO: Implement
 }

internal/distributed/mixcoord/client/client.go

@@ -338,6 +338,39 @@ func (c *Client) AlterCollectionField(ctx context.Context, request *milvuspb.Alt
 	})
 }
 
+func (c *Client) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	request = typeutil.Clone(request)
+	commonpbutil.UpdateMsgBase(
+		request.GetBase(),
+		commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())),
+	)
+	return wrapGrpcCall(ctx, c, func(client MixCoordClient) (*commonpb.Status, error) {
+		return client.AddCollectionFunction(ctx, request)
+	})
+}
+
+func (c *Client) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	request = typeutil.Clone(request)
+	commonpbutil.UpdateMsgBase(
+		request.GetBase(),
+		commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())),
+	)
+	return wrapGrpcCall(ctx, c, func(client MixCoordClient) (*commonpb.Status, error) {
+		return client.AlterCollectionFunction(ctx, request)
+	})
+}
+
+func (c *Client) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	request = typeutil.Clone(request)
+	commonpbutil.UpdateMsgBase(
+		request.GetBase(),
+		commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())),
+	)
+	return wrapGrpcCall(ctx, c, func(client MixCoordClient) (*commonpb.Status, error) {
+		return client.DropCollectionFunction(ctx, request)
+	})
+}
+
 // CreatePartition create partition
 func (c *Client) CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	in = typeutil.Clone(in)

internal/distributed/mixcoord/client/client_test.go

@@ -257,6 +257,18 @@ func Test_NewClient(t *testing.T) {
 			r, err := client.AlterCollection(ctx, nil)
 			retCheck(retNotNil, r, err)
 		}
+		{
+			r, err := client.AddCollectionFunction(ctx, nil)
+			retCheck(retNotNil, r, err)
+		}
+		{
+			r, err := client.AlterCollectionFunction(ctx, nil)
+			retCheck(retNotNil, r, err)
+		}
+		{
+			r, err := client.DropCollectionFunction(ctx, nil)
+			retCheck(retNotNil, r, err)
+		}
 		{
 			r, err := client.AlterDatabase(ctx, nil)
 			retCheck(retNotNil, r, err)

internal/distributed/mixcoord/service.go

@@ -531,6 +531,18 @@ func (s *Server) AlterCollectionField(ctx context.Context, request *milvuspb.Alt
 	return s.mixCoord.AlterCollectionField(ctx, request)
 }
 
+func (s *Server) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.mixCoord.AddCollectionFunction(ctx, request)
+}
+
+func (s *Server) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.mixCoord.AlterCollectionFunction(ctx, request)
+}
+
+func (s *Server) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.mixCoord.DropCollectionFunction(ctx, request)
+}
+
 func (s *Server) RenameCollection(ctx context.Context, request *milvuspb.RenameCollectionRequest) (*commonpb.Status, error) {
 	return s.mixCoord.RenameCollection(ctx, request)
 }

internal/distributed/proxy/httpserver/constant.go

@@ -69,6 +69,9 @@ const (
 	RevokePrivilegeActionV2         = "revoke_privilege_v2"
 	AlterAction                     = "alter"
 	AlterPropertiesAction           = "alter_properties"
+	AddFunctionAction               = "add_function"
+	AlterFunctionAction             = "alter_function"
+	DropFunctionAction              = "drop_function"
 	AddAction                       = `add`
 	DropPropertiesAction            = "drop_properties"
 	CompactAction                   = "compact"

internal/distributed/proxy/httpserver/handler_v2.go

@@ -81,6 +81,9 @@ func (h *HandlersV2) RegisterRoutesToV2(router gin.IRouter) {
 	router.POST(CollectionCategory+RefreshLoadAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionNameReq{} }, wrapperTraceLog(h.refreshLoadCollection))))
 	router.POST(CollectionCategory+ReleaseAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionNameReq{} }, wrapperTraceLog(h.releaseCollection))))
 	router.POST(CollectionCategory+AlterPropertiesAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionReqWithProperties{} }, wrapperTraceLog(h.alterCollectionProperties))))
+	router.POST(CollectionCategory+AddFunctionAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionAddFunction{} }, wrapperTraceLog(h.addCollectionFunction))))
+	router.POST(CollectionCategory+AlterFunctionAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionAlterFunction{} }, wrapperTraceLog(h.alterCollectionFunction))))
+	router.POST(CollectionCategory+DropFunctionAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionDropFunction{} }, wrapperTraceLog(h.dropCollectionFunction))))
 	router.POST(CollectionCategory+DropPropertiesAction, timeoutMiddleware(wrapperPost(func() any { return &DropCollectionPropertiesReq{} }, wrapperTraceLog(h.dropCollectionProperties))))
 	router.POST(CollectionCategory+CompactAction, timeoutMiddleware(wrapperPost(func() any { return &CompactReq{} }, wrapperTraceLog(h.compact))))
 	router.POST(CollectionCategory+CompactionStateAction, timeoutMiddleware(wrapperPost(func() any { return &GetCompactionStateReq{} }, wrapperTraceLog(h.getcompactionState))))
@@ -685,6 +688,74 @@ func (h *HandlersV2) alterCollectionProperties(ctx context.Context, c *gin.Conte
 	return resp, err
 }
 
+func (h *HandlersV2) addCollectionFunction(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) {
+	httpReq := anyReq.(*CollectionAddFunction)
+	req := &milvuspb.AddCollectionFunctionRequest{
+		DbName:         dbName,
+		CollectionName: httpReq.CollectionName,
+	}
+	fSchema, err := genFunctionSchema(ctx, &httpReq.Function)
+	if err != nil {
+		HTTPAbortReturn(c, http.StatusOK, gin.H{
+			HTTPReturnCode:    merr.Code(merr.ErrParameterInvalid),
+			HTTPReturnMessage: err.Error(),
+		})
+	}
+
+	req.FunctionSchema = fSchema
+	c.Set(ContextRequest, req)
+	resp, err := wrapperProxyWithLimit(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/AddCollectionFunction", true, h.proxy, func(reqCtx context.Context, req any) (interface{}, error) {
+		return h.proxy.AddCollectionFunction(reqCtx, req.(*milvuspb.AddCollectionFunctionRequest))
+	})
+	if err == nil {
+		HTTPReturn(c, http.StatusOK, wrapperReturnDefault())
+	}
+	return resp, err
+}
+
+func (h *HandlersV2) alterCollectionFunction(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) {
+	httpReq := anyReq.(*CollectionAlterFunction)
+	req := &milvuspb.AlterCollectionFunctionRequest{
+		DbName:         dbName,
+		CollectionName: httpReq.CollectionName,
+		FunctionName:   httpReq.FunctionName,
+	}
+	fSchema, err := genFunctionSchema(ctx, &httpReq.Function)
+	if err != nil {
+		HTTPAbortReturn(c, http.StatusOK, gin.H{
+			HTTPReturnCode:    merr.Code(merr.ErrParameterInvalid),
+			HTTPReturnMessage: err.Error(),
+		})
+	}
+
+	req.FunctionSchema = fSchema
+	c.Set(ContextRequest, req)
+	resp, err := wrapperProxyWithLimit(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/AlterCollectionFunction", true, h.proxy, func(reqCtx context.Context, req any) (interface{}, error) {
+		return h.proxy.AlterCollectionFunction(reqCtx, req.(*milvuspb.AlterCollectionFunctionRequest))
+	})
+	if err == nil {
+		HTTPReturn(c, http.StatusOK, wrapperReturnDefault())
+	}
+	return resp, err
+}
+
+func (h *HandlersV2) dropCollectionFunction(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) {
+	httpReq := anyReq.(*CollectionDropFunction)
+	req := &milvuspb.DropCollectionFunctionRequest{
+		DbName:         dbName,
+		CollectionName: httpReq.CollectionName,
+		FunctionName:   httpReq.FunctionName,
+	}
+	c.Set(ContextRequest, req)
+	resp, err := wrapperProxyWithLimit(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/DropCollectionFunction", true, h.proxy, func(reqCtx context.Context, req any) (interface{}, error) {
+		return h.proxy.DropCollectionFunction(reqCtx, req.(*milvuspb.DropCollectionFunctionRequest))
+	})
+	if err == nil {
+		HTTPReturn(c, http.StatusOK, wrapperReturnDefault())
+	}
+	return resp, err
+}
+
 func (h *HandlersV2) dropCollectionProperties(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) {
 	httpReq := anyReq.(*DropCollectionPropertiesReq)
 	req := &milvuspb.AlterCollectionRequest{

internal/distributed/proxy/httpserver/handler_v2_test.go

@@ -2872,3 +2872,112 @@ func (s *AddCollectionFieldSuite) TestAddCollectionFieldFail() {
 func TestAddCollectionFieldSuite(t *testing.T) {
 	suite.Run(t, new(AddCollectionFieldSuite))
 }
+
+func TestCollectionFunctionSuite(t *testing.T) {
+	suite.Run(t, new(CollectionFunctionSuite))
+}
+
+type CollectionFunctionSuite struct {
+	suite.Suite
+	testEngine *gin.Engine
+	mp         *mocks.MockProxy
+}
+
+func (s *CollectionFunctionSuite) SetupSuite() {
+	paramtable.Init()
+	// disable rate limit
+	paramtable.Get().Save(paramtable.Get().QuotaConfig.QuotaAndLimitsEnabled.Key, "false")
+}
+
+func (s *CollectionFunctionSuite) TearDownSuite() {
+	defer paramtable.Get().Reset(paramtable.Get().QuotaConfig.QuotaAndLimitsEnabled.Key)
+}
+
+func (s *CollectionFunctionSuite) SetupTest() {
+	s.mp = mocks.NewMockProxy(s.T())
+	s.testEngine = initHTTPServerV2(s.mp, false)
+}
+
+func (s *CollectionFunctionSuite) TestAddCollectionFunctionNormal() {
+	s.Run("success", func() {
+		addFunctionTestCases := []requestBodyTestCase{
+			{
+				path:        versionalV2(CollectionCategory, AddFunctionAction),
+				requestBody: []byte(`{"dbName": "db", "collectionName": "coll", "function": {"name": "test_function", "type": "TextEmbedding", "inputFieldNames": [], "OutputFieldNames": []}}`),
+				errCode:     0,
+				errMsg:      "",
+			},
+		}
+		s.mp.EXPECT().AddCollectionFunction(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil).Maybe()
+
+		validateRequestBodyTestCases(s.T(), s.testEngine, addFunctionTestCases, false)
+	})
+
+	s.Run("bad_request", func() {
+		addFunctionTestCases := []requestBodyTestCase{
+			{
+				path:        versionalV2(CollectionCategory, AddFunctionAction),
+				requestBody: []byte(`{"dbName": "db", "collectionName": "", "function": {"name": "test_function", "type": "BM25", "inputFieldNames": [], "OutputFieldNames": []}}`),
+				errCode:     1802,
+				errMsg:      "missing required parameters, error: Key: 'CollectionAddFunction.CollectionName' Error:Field validation for 'CollectionName' failed on the 'required' tag",
+			},
+			{
+				path:        versionalV2(CollectionCategory, AddFunctionAction),
+				requestBody: []byte(`invalid json`),
+				errCode:     1801,
+				errMsg:      "can only accept json format request, error: invalid character 'i' looking for beginning of value",
+			},
+		}
+		validateRequestBodyTestCases(s.T(), s.testEngine, addFunctionTestCases, false)
+	})
+}
+
+func (s *CollectionFunctionSuite) TestAlterCollectionFunctionNormal() {
+	s.Run("success", func() {
+		alterFunctionTestCases := []requestBodyTestCase{
+			{
+				path:        versionalV2(CollectionCategory, AlterFunctionAction),
+				requestBody: []byte(`{"dbName": "db", "collectionName": "coll", "functionName": "test_function", "function": {"name": "test_function", "type": "TextEmbedding", "inputFieldNames": [], "OutputFieldNames": []}}`),
+				errCode:     0,
+				errMsg:      "",
+			},
+		}
+		s.mp.EXPECT().AlterCollectionFunction(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil).Maybe()
+
+		validateRequestBodyTestCases(s.T(), s.testEngine, alterFunctionTestCases, false)
+	})
+
+	s.Run("bad_request", func() {
+		alterFunctionTestCases := []requestBodyTestCase{
+			{
+				path:        versionalV2(CollectionCategory, AlterFunctionAction),
+				requestBody: []byte(`{"dbName": "db", "collectionName": "", "functionName": "test_function", "function": {"name": "test_function", "type": "BM25", "inputFieldNames": [], "OutputFieldNames": []}}`),
+				errCode:     1802,
+				errMsg:      "missing required parameters, error: Key: 'CollectionAlterFunction.CollectionName' Error:Field validation for 'CollectionName' failed on the 'required' tag",
+			},
+			{
+				path:        versionalV2(CollectionCategory, AlterFunctionAction),
+				requestBody: []byte(`invalid json`),
+				errCode:     1801,
+				errMsg:      "can only accept json format request, error: invalid character 'i' looking for beginning of value",
+			},
+		}
+		validateRequestBodyTestCases(s.T(), s.testEngine, alterFunctionTestCases, false)
+	})
+}
+
+func (s *CollectionFunctionSuite) TestDropCollectionFunctionNormal() {
+	s.Run("success", func() {
+		addFunctionTestCases := []requestBodyTestCase{
+			{
+				path:        versionalV2(CollectionCategory, DropFunctionAction),
+				requestBody: []byte(`{"dbName": "db", "collectionName": "coll", "functionName": "test"}`),
+				errCode:     0,
+				errMsg:      "",
+			},
+		}
+		s.mp.EXPECT().DropCollectionFunction(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil).Maybe()
+
+		validateRequestBodyTestCases(s.T(), s.testEngine, addFunctionTestCases, false)
+	})
+}

internal/distributed/proxy/httpserver/request_v2.go

@@ -89,6 +89,59 @@ func (req *CollectionReqWithProperties) GetCollectionName() string {
 	return req.CollectionName
 }
 
+type CollectionDropFunction struct {
+	DbName         string `json:"dbName"`
+	CollectionName string `json:"collectionName" binding:"required"`
+	FunctionName   string `json:"FunctionName" binding:"required"`
+}
+
+func (req *CollectionDropFunction) GetDbName() string { return req.DbName }
+
+func (req *CollectionDropFunction) GetCollectionName() string {
+	return req.CollectionName
+}
+
+func (req *CollectionDropFunction) GetFunctionName() string {
+	return req.FunctionName
+}
+
+type CollectionAddFunction struct {
+	DbName         string         `json:"dbName"`
+	CollectionName string         `json:"collectionName" binding:"required"`
+	Function       FunctionSchema `json:"function" binding:"required"`
+}
+
+func (req *CollectionAddFunction) GetDbName() string { return req.DbName }
+
+func (req *CollectionAddFunction) GetCollectionName() string {
+	return req.CollectionName
+}
+
+func (req *CollectionAddFunction) GetFunction() *FunctionSchema {
+	return &req.Function
+}
+
+type CollectionAlterFunction struct {
+	DbName         string         `json:"dbName"`
+	CollectionName string         `json:"collectionName" binding:"required"`
+	FunctionName   string         `json:"functionName" binding:"required"`
+	Function       FunctionSchema `json:"function" binding:"required"`
+}
+
+func (req *CollectionAlterFunction) GetDbName() string { return req.DbName }
+
+func (req *CollectionAlterFunction) GetCollectionName() string {
+	return req.CollectionName
+}
+
+func (req *CollectionAlterFunction) GetFunctionName() string {
+	return req.FunctionName
+}
+
+func (req *CollectionAlterFunction) GetFunction() *FunctionSchema {
+	return &req.Function
+}
+
 type OptionalCollectionNameReq struct {
 	DbName         string `json:"dbName"`
 	CollectionName string `json:"collectionName"`

internal/distributed/proxy/service.go

@@ -671,6 +671,18 @@ func (s *Server) AlterCollectionField(ctx context.Context, request *milvuspb.Alt
 	return s.proxy.AlterCollectionField(ctx, request)
 }
 
+func (s *Server) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.proxy.AddCollectionFunction(ctx, request)
+}
+
+func (s *Server) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.proxy.AlterCollectionFunction(ctx, request)
+}
+
+func (s *Server) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	return s.proxy.DropCollectionFunction(ctx, request)
+}
+
 // CreatePartition notifies Proxy to create a partition
 func (s *Server) CreatePartition(ctx context.Context, request *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
 	return s.proxy.CreatePartition(ctx, request)

internal/metastore/kv/rootcoord/kv_catalog.go

@@ -725,6 +725,15 @@ func (kc *Catalog) alterModifyCollection(ctx context.Context, oldColl *model.Col
 			}
 			saves[k] = string(v)
 		}
+		for _, function := range newColl.Functions {
+			k := BuildFunctionKey(newColl.CollectionID, function.ID)
+			functionInfo := model.MarshalFunctionModel(function)
+			v, err := proto.Marshal(functionInfo)
+			if err != nil {
+				return err
+			}
+			saves[k] = string(v)
+		}
 	}
 
 	maxTxnNum := paramtable.Get().MetaStoreCfg.MaxEtcdTxnNum.GetAsInt()

internal/metastore/kv/rootcoord/kv_catalog_test.go

@@ -1117,6 +1117,29 @@ func TestCatalog_AlterCollection(t *testing.T) {
 		err := kc.AlterCollection(ctx, oldC, newC, metastore.MODIFY, 0, true)
 		assert.NoError(t, err)
 	})
+
+	t.Run("modify function", func(t *testing.T) {
+		var collectionID int64 = 1
+		snapshot := kv.NewMockSnapshotKV()
+		snapshot.MultiSaveFunc = func(ctx context.Context, saves map[string]string, ts typeutil.Timestamp) error {
+			assert.LessOrEqual(t, len(saves), 64)
+			return nil
+		}
+
+		kc := NewCatalog(nil, snapshot).(*Catalog)
+		ctx := context.Background()
+
+		functions := []*model.Function{
+			{
+				Name: "test_function",
+			},
+		}
+
+		oldC := &model.Collection{DBID: 0, CollectionID: collectionID, State: pb.CollectionState_CollectionCreated}
+		newC := &model.Collection{DBID: 0, CollectionID: collectionID, State: pb.CollectionState_CollectionCreated, Functions: functions}
+		err := kc.AlterCollection(ctx, oldC, newC, metastore.MODIFY, 0, true)
+		assert.NoError(t, err)
+	})
 }
 
 func TestCatalog_AlterCollectionDB(t *testing.T) {

internal/metastore/mocks/mock_rootcoord_catalog.go

@@ -655,53 +655,6 @@ func (_c *RootCoordCatalog_CreateCollection_Call) RunAndReturn(run func(context.
 	return _c
 }
 
-// CreateCredential provides a mock function with given fields: ctx, credential
-func (_m *RootCoordCatalog) CreateCredential(ctx context.Context, credential *model.Credential) error {
-	ret := _m.Called(ctx, credential)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CreateCredential")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *model.Credential) error); ok {
-		r0 = rf(ctx, credential)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// RootCoordCatalog_CreateCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCredential'
-type RootCoordCatalog_CreateCredential_Call struct {
-	*mock.Call
-}
-
-// CreateCredential is a helper method to define mock.On call
-//   - ctx context.Context
-//   - credential *model.Credential
-func (_e *RootCoordCatalog_Expecter) CreateCredential(ctx interface{}, credential interface{}) *RootCoordCatalog_CreateCredential_Call {
-	return &RootCoordCatalog_CreateCredential_Call{Call: _e.mock.On("CreateCredential", ctx, credential)}
-}
-
-func (_c *RootCoordCatalog_CreateCredential_Call) Run(run func(ctx context.Context, credential *model.Credential)) *RootCoordCatalog_CreateCredential_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*model.Credential))
-	})
-	return _c
-}
-
-func (_c *RootCoordCatalog_CreateCredential_Call) Return(_a0 error) *RootCoordCatalog_CreateCredential_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *RootCoordCatalog_CreateCredential_Call) RunAndReturn(run func(context.Context, *model.Credential) error) *RootCoordCatalog_CreateCredential_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
 // CreateDatabase provides a mock function with given fields: ctx, db, ts
 func (_m *RootCoordCatalog) CreateDatabase(ctx context.Context, db *model.Database, ts uint64) error {
 	ret := _m.Called(ctx, db, ts)

internal/mocks/mock_mixcoord.go

@@ -162,6 +162,65 @@ func (_c *MixCoord_AddCollectionField_Call) RunAndReturn(run func(context.Contex
 	return _c
 }
 
+// AddCollectionFunction provides a mock function with given fields: _a0, _a1
+func (_m *MixCoord) AddCollectionFunction(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) *commonpb.Status); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MixCoord_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction'
+type MixCoord_AddCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AddCollectionFunction is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *milvuspb.AddCollectionFunctionRequest
+func (_e *MixCoord_Expecter) AddCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_AddCollectionFunction_Call {
+	return &MixCoord_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", _a0, _a1)}
+}
+
+func (_c *MixCoord_AddCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest)) *MixCoord_AddCollectionFunction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFunctionRequest))
+	})
+	return _c
+}
+
+func (_c *MixCoord_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MixCoord_AddCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MixCoord_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_AddCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AddFileResource provides a mock function with given fields: _a0, _a1
 func (_m *MixCoord) AddFileResource(_a0 context.Context, _a1 *milvuspb.AddFileResourceRequest) (*commonpb.Status, error) {
 	ret := _m.Called(_a0, _a1)
@@ -575,6 +634,65 @@ func (_c *MixCoord_AlterCollectionField_Call) RunAndReturn(run func(context.Cont
 	return _c
 }
 
+// AlterCollectionFunction provides a mock function with given fields: _a0, _a1
+func (_m *MixCoord) AlterCollectionFunction(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AlterCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) *commonpb.Status); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MixCoord_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction'
+type MixCoord_AlterCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AlterCollectionFunction is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *milvuspb.AlterCollectionFunctionRequest
+func (_e *MixCoord_Expecter) AlterCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_AlterCollectionFunction_Call {
+	return &MixCoord_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", _a0, _a1)}
+}
+
+func (_c *MixCoord_AlterCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest)) *MixCoord_AlterCollectionFunction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFunctionRequest))
+	})
+	return _c
+}
+
+func (_c *MixCoord_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MixCoord_AlterCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MixCoord_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_AlterCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AlterDatabase provides a mock function with given fields: _a0, _a1
 func (_m *MixCoord) AlterDatabase(_a0 context.Context, _a1 *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error) {
 	ret := _m.Called(_a0, _a1)
@@ -2168,6 +2286,65 @@ func (_c *MixCoord_DropCollection_Call) RunAndReturn(run func(context.Context, *
 	return _c
 }
 
+// DropCollectionFunction provides a mock function with given fields: _a0, _a1
+func (_m *MixCoord) DropCollectionFunction(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DropCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) *commonpb.Status); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MixCoord_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction'
+type MixCoord_DropCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// DropCollectionFunction is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *milvuspb.DropCollectionFunctionRequest
+func (_e *MixCoord_Expecter) DropCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_DropCollectionFunction_Call {
+	return &MixCoord_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", _a0, _a1)}
+}
+
+func (_c *MixCoord_DropCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest)) *MixCoord_DropCollectionFunction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionFunctionRequest))
+	})
+	return _c
+}
+
+func (_c *MixCoord_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MixCoord_DropCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MixCoord_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_DropCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // DropDatabase provides a mock function with given fields: _a0, _a1
 func (_m *MixCoord) DropDatabase(_a0 context.Context, _a1 *milvuspb.DropDatabaseRequest) (*commonpb.Status, error) {
 	ret := _m.Called(_a0, _a1)

internal/mocks/mock_mixcoord_client.go

@@ -187,6 +187,80 @@ func (_c *MockMixCoordClient_AddCollectionField_Call) RunAndReturn(run func(cont
 	return _c
 }
 
+// AddCollectionFunction provides a mock function with given fields: ctx, in, opts
+func (_m *MockMixCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, 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 AddCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockMixCoordClient_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction'
+type MockMixCoordClient_AddCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AddCollectionFunction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *milvuspb.AddCollectionFunctionRequest
+//   - opts ...grpc.CallOption
+func (_e *MockMixCoordClient_Expecter) AddCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AddCollectionFunction_Call {
+	return &MockMixCoordClient_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockMixCoordClient_AddCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AddCollectionFunction_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].(*milvuspb.AddCollectionFunctionRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockMixCoordClient_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockMixCoordClient_AddCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockMixCoordClient_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_AddCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AddFileResource provides a mock function with given fields: ctx, in, opts
 func (_m *MockMixCoordClient) AddFileResource(ctx context.Context, in *milvuspb.AddFileResourceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	_va := make([]interface{}, len(opts))
@@ -705,6 +779,80 @@ func (_c *MockMixCoordClient_AlterCollectionField_Call) RunAndReturn(run func(co
 	return _c
 }
 
+// AlterCollectionFunction provides a mock function with given fields: ctx, in, opts
+func (_m *MockMixCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, 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 AlterCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockMixCoordClient_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction'
+type MockMixCoordClient_AlterCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AlterCollectionFunction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *milvuspb.AlterCollectionFunctionRequest
+//   - opts ...grpc.CallOption
+func (_e *MockMixCoordClient_Expecter) AlterCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterCollectionFunction_Call {
+	return &MockMixCoordClient_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockMixCoordClient_AlterCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterCollectionFunction_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].(*milvuspb.AlterCollectionFunctionRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockMixCoordClient_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockMixCoordClient_AlterCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockMixCoordClient_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_AlterCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AlterDatabase provides a mock function with given fields: ctx, in, opts
 func (_m *MockMixCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	_va := make([]interface{}, len(opts))
@@ -2748,6 +2896,80 @@ func (_c *MockMixCoordClient_DropCollection_Call) RunAndReturn(run func(context.
 	return _c
 }
 
+// DropCollectionFunction provides a mock function with given fields: ctx, in, opts
+func (_m *MockMixCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, 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 DropCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockMixCoordClient_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction'
+type MockMixCoordClient_DropCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// DropCollectionFunction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *milvuspb.DropCollectionFunctionRequest
+//   - opts ...grpc.CallOption
+func (_e *MockMixCoordClient_Expecter) DropCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropCollectionFunction_Call {
+	return &MockMixCoordClient_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockMixCoordClient_DropCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropCollectionFunction_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].(*milvuspb.DropCollectionFunctionRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockMixCoordClient_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockMixCoordClient_DropCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockMixCoordClient_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_DropCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // DropDatabase provides a mock function with given fields: ctx, in, opts
 func (_m *MockMixCoordClient) DropDatabase(ctx context.Context, in *milvuspb.DropDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	_va := make([]interface{}, len(opts))

internal/mocks/mock_rootcoord.go

@@ -95,6 +95,65 @@ func (_c *MockRootCoord_AddCollectionField_Call) RunAndReturn(run func(context.C
 	return _c
 }
 
+// AddCollectionFunction provides a mock function with given fields: _a0, _a1
+func (_m *MockRootCoord) AddCollectionFunction(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) *commonpb.Status); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockRootCoord_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction'
+type MockRootCoord_AddCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AddCollectionFunction is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *milvuspb.AddCollectionFunctionRequest
+func (_e *MockRootCoord_Expecter) AddCollectionFunction(_a0 interface{}, _a1 interface{}) *MockRootCoord_AddCollectionFunction_Call {
+	return &MockRootCoord_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", _a0, _a1)}
+}
+
+func (_c *MockRootCoord_AddCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest)) *MockRootCoord_AddCollectionFunction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFunctionRequest))
+	})
+	return _c
+}
+
+func (_c *MockRootCoord_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoord_AddCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockRootCoord_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)) *MockRootCoord_AddCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AllocID provides a mock function with given fields: _a0, _a1
 func (_m *MockRootCoord) AllocID(_a0 context.Context, _a1 *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
 	ret := _m.Called(_a0, _a1)
@@ -390,6 +449,65 @@ func (_c *MockRootCoord_AlterCollectionField_Call) RunAndReturn(run func(context
 	return _c
 }
 
+// AlterCollectionFunction provides a mock function with given fields: _a0, _a1
+func (_m *MockRootCoord) AlterCollectionFunction(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AlterCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) *commonpb.Status); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockRootCoord_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction'
+type MockRootCoord_AlterCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AlterCollectionFunction is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *milvuspb.AlterCollectionFunctionRequest
+func (_e *MockRootCoord_Expecter) AlterCollectionFunction(_a0 interface{}, _a1 interface{}) *MockRootCoord_AlterCollectionFunction_Call {
+	return &MockRootCoord_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", _a0, _a1)}
+}
+
+func (_c *MockRootCoord_AlterCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest)) *MockRootCoord_AlterCollectionFunction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFunctionRequest))
+	})
+	return _c
+}
+
+func (_c *MockRootCoord_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoord_AlterCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockRootCoord_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)) *MockRootCoord_AlterCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AlterDatabase provides a mock function with given fields: _a0, _a1
 func (_m *MockRootCoord) AlterDatabase(_a0 context.Context, _a1 *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error) {
 	ret := _m.Called(_a0, _a1)
@@ -1393,6 +1511,65 @@ func (_c *MockRootCoord_DropCollection_Call) RunAndReturn(run func(context.Conte
 	return _c
 }
 
+// DropCollectionFunction provides a mock function with given fields: _a0, _a1
+func (_m *MockRootCoord) DropCollectionFunction(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DropCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) *commonpb.Status); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockRootCoord_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction'
+type MockRootCoord_DropCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// DropCollectionFunction is a helper method to define mock.On call
+//   - _a0 context.Context
+//   - _a1 *milvuspb.DropCollectionFunctionRequest
+func (_e *MockRootCoord_Expecter) DropCollectionFunction(_a0 interface{}, _a1 interface{}) *MockRootCoord_DropCollectionFunction_Call {
+	return &MockRootCoord_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", _a0, _a1)}
+}
+
+func (_c *MockRootCoord_DropCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest)) *MockRootCoord_DropCollectionFunction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionFunctionRequest))
+	})
+	return _c
+}
+
+func (_c *MockRootCoord_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoord_DropCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockRootCoord_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)) *MockRootCoord_DropCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // DropDatabase provides a mock function with given fields: _a0, _a1
 func (_m *MockRootCoord) DropDatabase(_a0 context.Context, _a1 *milvuspb.DropDatabaseRequest) (*commonpb.Status, error) {
 	ret := _m.Called(_a0, _a1)

internal/mocks/mock_rootcoord_client.go

@@ -107,6 +107,80 @@ func (_c *MockRootCoordClient_AddCollectionField_Call) RunAndReturn(run func(con
 	return _c
 }
 
+// AddCollectionFunction provides a mock function with given fields: ctx, in, opts
+func (_m *MockRootCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, 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 AddCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockRootCoordClient_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction'
+type MockRootCoordClient_AddCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AddCollectionFunction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *milvuspb.AddCollectionFunctionRequest
+//   - opts ...grpc.CallOption
+func (_e *MockRootCoordClient_Expecter) AddCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_AddCollectionFunction_Call {
+	return &MockRootCoordClient_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockRootCoordClient_AddCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption)) *MockRootCoordClient_AddCollectionFunction_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].(*milvuspb.AddCollectionFunctionRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockRootCoordClient_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoordClient_AddCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockRootCoordClient_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockRootCoordClient_AddCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AllocID provides a mock function with given fields: ctx, in, opts
 func (_m *MockRootCoordClient) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest, opts ...grpc.CallOption) (*rootcoordpb.AllocIDResponse, error) {
 	_va := make([]interface{}, len(opts))
@@ -477,6 +551,80 @@ func (_c *MockRootCoordClient_AlterCollectionField_Call) RunAndReturn(run func(c
 	return _c
 }
 
+// AlterCollectionFunction provides a mock function with given fields: ctx, in, opts
+func (_m *MockRootCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, 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 AlterCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockRootCoordClient_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction'
+type MockRootCoordClient_AlterCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// AlterCollectionFunction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *milvuspb.AlterCollectionFunctionRequest
+//   - opts ...grpc.CallOption
+func (_e *MockRootCoordClient_Expecter) AlterCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_AlterCollectionFunction_Call {
+	return &MockRootCoordClient_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockRootCoordClient_AlterCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption)) *MockRootCoordClient_AlterCollectionFunction_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].(*milvuspb.AlterCollectionFunctionRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockRootCoordClient_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoordClient_AlterCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockRootCoordClient_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockRootCoordClient_AlterCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // AlterDatabase provides a mock function with given fields: ctx, in, opts
 func (_m *MockRootCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	_va := make([]interface{}, len(opts))
@@ -1780,6 +1928,80 @@ func (_c *MockRootCoordClient_DropCollection_Call) RunAndReturn(run func(context
 	return _c
 }
 
+// DropCollectionFunction provides a mock function with given fields: ctx, in, opts
+func (_m *MockRootCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, 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 DropCollectionFunction")
+	}
+
+	var r0 *commonpb.Status
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok {
+		return rf(ctx, in, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockRootCoordClient_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction'
+type MockRootCoordClient_DropCollectionFunction_Call struct {
+	*mock.Call
+}
+
+// DropCollectionFunction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *milvuspb.DropCollectionFunctionRequest
+//   - opts ...grpc.CallOption
+func (_e *MockRootCoordClient_Expecter) DropCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_DropCollectionFunction_Call {
+	return &MockRootCoordClient_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockRootCoordClient_DropCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption)) *MockRootCoordClient_DropCollectionFunction_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].(*milvuspb.DropCollectionFunctionRequest), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockRootCoordClient_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoordClient_DropCollectionFunction_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockRootCoordClient_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockRootCoordClient_DropCollectionFunction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // DropDatabase provides a mock function with given fields: ctx, in, opts
 func (_m *MockRootCoordClient) DropDatabase(ctx context.Context, in *milvuspb.DropDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	_va := make([]interface{}, len(opts))

internal/proxy/function_task.go

@@ -0,0 +1,331 @@
+// 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 proxy
+
+import (
+	"context"
+	"fmt"
+
+	"go.uber.org/zap"
+	"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/schemapb"
+	"github.com/milvus-io/milvus/internal/types"
+	"github.com/milvus-io/milvus/pkg/v2/log"
+	"github.com/milvus-io/milvus/pkg/v2/util/commonpbutil"
+	"github.com/milvus-io/milvus/pkg/v2/util/merr"
+	"github.com/milvus-io/milvus/pkg/v2/util/paramtable"
+)
+
+type addCollectionFunctionTask struct {
+	baseTask
+	Condition
+	*milvuspb.AddCollectionFunctionRequest
+	ctx      context.Context
+	mixCoord types.MixCoordClient
+	result   *commonpb.Status
+}
+
+func (t *addCollectionFunctionTask) TraceCtx() context.Context {
+	return t.ctx
+}
+
+func (t *addCollectionFunctionTask) ID() UniqueID {
+	return t.Base.MsgID
+}
+
+func (t *addCollectionFunctionTask) SetID(uid UniqueID) {
+	t.Base.MsgID = uid
+}
+
+func (t *addCollectionFunctionTask) Type() commonpb.MsgType {
+	return t.Base.MsgType
+}
+
+func (t *addCollectionFunctionTask) BeginTs() Timestamp {
+	return t.Base.Timestamp
+}
+
+func (t *addCollectionFunctionTask) EndTs() Timestamp {
+	return t.Base.Timestamp
+}
+
+func (t *addCollectionFunctionTask) SetTs(ts Timestamp) {
+	t.Base.Timestamp = ts
+}
+
+func (t *addCollectionFunctionTask) OnEnqueue() error {
+	if t.Base == nil {
+		t.Base = commonpbutil.NewMsgBase()
+	}
+	t.Base.MsgType = commonpb.MsgType_AddCollectionFunction
+	t.Base.SourceID = paramtable.GetNodeID()
+	return nil
+}
+
+func (t *addCollectionFunctionTask) Name() string {
+	return AddCollectionFunctionTask
+}
+
+func (t *addCollectionFunctionTask) PreExecute(ctx context.Context) error {
+	if t.FunctionSchema == nil {
+		return fmt.Errorf("Function Schema is empty")
+	}
+
+	if t.FunctionSchema.Type == schemapb.FunctionType_BM25 {
+		return fmt.Errorf("Currently does not support adding BM25 function")
+	}
+	coll, err := getCollectionInfo(ctx, t.GetDbName(), t.GetCollectionName())
+	if err != nil {
+		log.Ctx(t.ctx).Error("AddCollectionTask, get collection info failed",
+			zap.String("dbName", t.GetDbName()),
+			zap.String("collectionName", t.GetCollectionName()),
+			zap.Error(err))
+		return err
+	}
+	newColl := proto.Clone(coll.schema.CollectionSchema).(*schemapb.CollectionSchema)
+	newColl.Functions = append(coll.schema.CollectionSchema.Functions, t.FunctionSchema)
+	if err := validateFunction(newColl); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *addCollectionFunctionTask) Execute(ctx context.Context) error {
+	var err error
+	t.result, err = t.mixCoord.AddCollectionFunction(ctx, t.AddCollectionFunctionRequest)
+	if err = merr.CheckRPCCall(t.result, err); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *addCollectionFunctionTask) PostExecute(ctx context.Context) error {
+	return nil
+}
+
+type alterCollectionFunctionTask struct {
+	baseTask
+	Condition
+	*milvuspb.AlterCollectionFunctionRequest
+	ctx      context.Context
+	mixCoord types.MixCoordClient
+	result   *commonpb.Status
+}
+
+func (t *alterCollectionFunctionTask) TraceCtx() context.Context {
+	return t.ctx
+}
+
+func (t *alterCollectionFunctionTask) ID() UniqueID {
+	return t.Base.MsgID
+}
+
+func (t *alterCollectionFunctionTask) SetID(uid UniqueID) {
+	t.Base.MsgID = uid
+}
+
+func (t *alterCollectionFunctionTask) Type() commonpb.MsgType {
+	return t.Base.MsgType
+}
+
+func (t *alterCollectionFunctionTask) BeginTs() Timestamp {
+	return t.Base.Timestamp
+}
+
+func (t *alterCollectionFunctionTask) EndTs() Timestamp {
+	return t.Base.Timestamp
+}
+
+func (t *alterCollectionFunctionTask) SetTs(ts Timestamp) {
+	t.Base.Timestamp = ts
+}
+
+func (t *alterCollectionFunctionTask) OnEnqueue() error {
+	if t.Base == nil {
+		t.Base = commonpbutil.NewMsgBase()
+	}
+	t.Base.MsgType = commonpb.MsgType_AlterCollectionFunction
+	t.Base.SourceID = paramtable.GetNodeID()
+	return nil
+}
+
+func (t *alterCollectionFunctionTask) Name() string {
+	return AlterCollectionFunctionTask
+}
+
+func (t *alterCollectionFunctionTask) PreExecute(ctx context.Context) error {
+	if t.FunctionSchema == nil {
+		return fmt.Errorf("Function Schema is empty")
+	}
+	if t.FunctionSchema.Type == schemapb.FunctionType_BM25 {
+		return fmt.Errorf("Currently does not support alter BM25 function")
+	}
+	if t.FunctionName != t.FunctionSchema.Name {
+		return fmt.Errorf("Invalid function config, name not match")
+	}
+	coll, err := getCollectionInfo(ctx, t.GetDbName(), t.GetCollectionName())
+	if err != nil {
+		log.Ctx(t.ctx).Error("AddCollectionTask, get collection info failed",
+			zap.String("dbName", t.GetDbName()),
+			zap.String("collectionName", t.GetCollectionName()),
+			zap.Error(err))
+		return err
+	}
+	funcExist := false
+	newFunctions := []*schemapb.FunctionSchema{}
+	for _, fSchema := range coll.schema.Functions {
+		if t.FunctionName == fSchema.Name {
+			if fSchema.Type == schemapb.FunctionType_BM25 {
+				return fmt.Errorf("Currently does not support alter BM25 function")
+			}
+			newFunctions = append(newFunctions, t.FunctionSchema)
+			funcExist = true
+		} else {
+			newFunctions = append(newFunctions, fSchema)
+		}
+	}
+	if !funcExist {
+		return fmt.Errorf("Function %s not found", t.FunctionName)
+	}
+
+	newColl := proto.Clone(coll.schema.CollectionSchema).(*schemapb.CollectionSchema)
+	newColl.Functions = newFunctions
+	if err := validateFunction(newColl); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *alterCollectionFunctionTask) Execute(ctx context.Context) error {
+	var err error
+	t.result, err = t.mixCoord.AlterCollectionFunction(ctx, t.AlterCollectionFunctionRequest)
+	if err = merr.CheckRPCCall(t.result, err); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *alterCollectionFunctionTask) PostExecute(ctx context.Context) error {
+	return nil
+}
+
+type dropCollectionFunctionTask struct {
+	baseTask
+	Condition
+	*milvuspb.DropCollectionFunctionRequest
+	ctx      context.Context
+	mixCoord types.MixCoordClient
+
+	result  *commonpb.Status
+	fSchema *schemapb.FunctionSchema
+}
+
+func (t *dropCollectionFunctionTask) TraceCtx() context.Context {
+	return t.ctx
+}
+
+func (t *dropCollectionFunctionTask) ID() UniqueID {
+	return t.Base.MsgID
+}
+
+func (t *dropCollectionFunctionTask) SetID(uid UniqueID) {
+	t.Base.MsgID = uid
+}
+
+func (t *dropCollectionFunctionTask) Type() commonpb.MsgType {
+	return t.Base.MsgType
+}
+
+func (t *dropCollectionFunctionTask) BeginTs() Timestamp {
+	return t.Base.Timestamp
+}
+
+func (t *dropCollectionFunctionTask) EndTs() Timestamp {
+	return t.Base.Timestamp
+}
+
+func (t *dropCollectionFunctionTask) SetTs(ts Timestamp) {
+	t.Base.Timestamp = ts
+}
+
+func (t *dropCollectionFunctionTask) OnEnqueue() error {
+	if t.Base == nil {
+		t.Base = commonpbutil.NewMsgBase()
+	}
+	t.Base.MsgType = commonpb.MsgType_DropCollectionFunction
+	t.Base.SourceID = paramtable.GetNodeID()
+	return nil
+}
+
+func (t *dropCollectionFunctionTask) Name() string {
+	return DropCollectionFunctionTask
+}
+
+func (t *dropCollectionFunctionTask) PreExecute(ctx context.Context) error {
+	coll, err := getCollectionInfo(ctx, t.GetDbName(), t.GetCollectionName())
+	if err != nil {
+		log.Ctx(t.ctx).Error("DropFunctionTask, get collection info failed",
+			zap.String("dbName", t.GetDbName()),
+			zap.String("collectionName", t.GetCollectionName()),
+			zap.Error(err))
+		return err
+	}
+
+	for _, f := range coll.schema.Functions {
+		if f.Name == t.FunctionName {
+			t.fSchema = f
+			break
+		}
+	}
+	return nil
+}
+
+func (t *dropCollectionFunctionTask) Execute(ctx context.Context) error {
+	if t.fSchema == nil {
+		return nil
+	}
+
+	if t.fSchema.Type == schemapb.FunctionType_BM25 {
+		return fmt.Errorf("Currently does not support droping BM25 function")
+	}
+
+	var err error
+	t.result, err = t.mixCoord.DropCollectionFunction(ctx, t.DropCollectionFunctionRequest)
+	if err = merr.CheckRPCCall(t.result, err); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *dropCollectionFunctionTask) PostExecute(ctx context.Context) error {
+	return nil
+}
+
+func getCollectionInfo(ctx context.Context, dbName string, collectionName string) (*collectionInfo, error) {
+	collID, err := globalMetaCache.GetCollectionID(ctx, dbName, collectionName)
+	if err != nil {
+		return nil, err
+	}
+	coll, err := globalMetaCache.GetCollectionInfo(ctx, dbName, collectionName, collID)
+	if err != nil {
+		return nil, err
+	}
+	return coll, nil
+}

internal/proxy/function_task_test.go

@@ -0,0 +1,750 @@
+// 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 proxy
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/bytedance/mockey"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	"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"
+)
+
+type FunctionTaskSuite struct {
+	suite.Suite
+}
+
+func TestFunctionTask(t *testing.T) {
+	suite.Run(t, new(FunctionTaskSuite))
+}
+
+func (f *FunctionTaskSuite) TestFunctionOnType() {
+	{
+		task := &addCollectionFunctionTask{
+			AddCollectionFunctionRequest: &milvuspb.AddCollectionFunctionRequest{},
+		}
+		err := task.OnEnqueue()
+		f.NoError(err)
+		f.Equal(commonpb.MsgType_AddCollectionFunction, task.Type())
+		f.Equal(task.TraceCtx(), task.ctx)
+		task.SetID(1)
+		f.Equal(task.ID(), int64(1))
+		task.SetTs(2)
+		f.Equal(task.EndTs(), uint64(2))
+		f.Equal(task.Name(), AddCollectionFunctionTask)
+	}
+	{
+		task := &dropCollectionFunctionTask{
+			DropCollectionFunctionRequest: &milvuspb.DropCollectionFunctionRequest{},
+		}
+		err := task.OnEnqueue()
+		f.NoError(err)
+		f.Equal(commonpb.MsgType_DropCollectionFunction, task.Type())
+		f.Equal(task.TraceCtx(), task.ctx)
+		task.SetID(1)
+		f.Equal(task.ID(), int64(1))
+		task.SetTs(2)
+		f.Equal(task.EndTs(), uint64(2))
+		f.Equal(task.Name(), DropCollectionFunctionTask)
+	}
+	{
+		task := &alterCollectionFunctionTask{
+			AlterCollectionFunctionRequest: &milvuspb.AlterCollectionFunctionRequest{},
+		}
+		err := task.OnEnqueue()
+		f.NoError(err)
+		f.Equal(commonpb.MsgType_AlterCollectionFunction, task.Type())
+		f.Equal(task.TraceCtx(), task.ctx)
+		task.SetID(1)
+		f.Equal(task.ID(), int64(1))
+		task.SetTs(2)
+		f.Equal(task.EndTs(), uint64(2))
+		f.Equal(task.Name(), AlterCollectionFunctionTask)
+	}
+}
+
+func (f *FunctionTaskSuite) TestAddCollectionFunctionTaskPreExecute() {
+	ctx := context.Background()
+	{
+		mixc := mocks.NewMockMixCoordClient(f.T())
+		req := &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			DbName:         "db",
+			CollectionName: "NotExist",
+			CollectionID:   1,
+			FunctionSchema: &schemapb.FunctionSchema{},
+		}
+
+		task := &addCollectionFunctionTask{
+			Condition:                    NewTaskCondition(ctx),
+			AddCollectionFunctionRequest: req,
+			mixCoord:                     mixc,
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(0, fmt.Errorf("Mock Error")).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "Mock Error")
+	}
+	{
+		// Test with invalid function schema
+		mixc := mocks.NewMockMixCoordClient(f.T())
+		req := &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionSchema: &schemapb.FunctionSchema{},
+		}
+
+		task := &addCollectionFunctionTask{
+			Condition:                    NewTaskCondition(ctx),
+			AddCollectionFunctionRequest: req,
+			mixCoord:                     mixc,
+		}
+
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, fmt.Errorf("Mock info error")).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "Mock info error")
+	}
+
+	{
+		// Test with valid request
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_BM25,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"sparse_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionSchema: functionSchema,
+		}
+
+		task := &addCollectionFunctionTask{
+			Condition:                    NewTaskCondition(ctx),
+			AddCollectionFunctionRequest: req,
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, nil).Maybe()
+		globalMetaCache = cache
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "not support adding BM25")
+	}
+	{
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_TextEmbedding,
+			InputFieldNames:  []string{"text"},
+			OutputFieldNames: []string{"vec"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionSchema: functionSchema,
+		}
+
+		task := &addCollectionFunctionTask{
+			Condition:                    NewTaskCondition(ctx),
+			AddCollectionFunctionRequest: req,
+		}
+		coll := &collectionInfo{
+			schema: &schemaInfo{
+				CollectionSchema: &schemapb.CollectionSchema{
+					Functions: []*schemapb.FunctionSchema{},
+				},
+			},
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe()
+		m := mockey.Mock(validateFunction).Return(nil).Build()
+		defer m.UnPatch()
+		globalMetaCache = cache
+		err := task.PreExecute(ctx)
+		f.NoError(err)
+	}
+}
+
+func (f *FunctionTaskSuite) TestAlterCollectionFunctionTaskPreExecute() {
+	ctx := context.Background()
+
+	{
+		mixc := mocks.NewMockMixCoordClient(f.T())
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			DbName:         "db",
+			CollectionName: "NotExist",
+			FunctionName:   "test",
+			CollectionID:   1,
+			FunctionSchema: &schemapb.FunctionSchema{Name: "test"},
+		}
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+			mixCoord:                       mixc,
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(0, fmt.Errorf("Mock Error")).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "Mock Error")
+	}
+	{
+		// Test with invalid function schema
+		mixc := mocks.NewMockMixCoordClient(f.T())
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test",
+			FunctionSchema: &schemapb.FunctionSchema{Name: "test"},
+		}
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+			mixCoord:                       mixc,
+		}
+
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, fmt.Errorf("Mock info error")).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "Mock info error")
+	}
+	{
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_BM25,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"sparse_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+			FunctionSchema: functionSchema,
+		}
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, nil).Maybe()
+		globalMetaCache = cache
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "not support alter BM25")
+	}
+	{
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_TextEmbedding,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"vector_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+			FunctionSchema: functionSchema,
+		}
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		coll := &collectionInfo{
+			schema: &schemaInfo{
+				CollectionSchema: &schemapb.CollectionSchema{
+					Functions: []*schemapb.FunctionSchema{
+						{Name: req.FunctionName, Type: schemapb.FunctionType_BM25},
+					},
+				},
+			},
+		}
+
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe()
+		globalMetaCache = cache
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "not support alter BM25")
+	}
+	{
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_TextEmbedding,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"dense_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "NotEqual",
+			FunctionSchema: functionSchema,
+		}
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, nil).Maybe()
+		globalMetaCache = cache
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "Invalid function config, name not match")
+	}
+	{
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_TextEmbedding,
+			InputFieldNames:  []string{"text"},
+			OutputFieldNames: []string{"vec"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+			FunctionSchema: functionSchema,
+		}
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+		}
+		coll := &collectionInfo{
+			schema: &schemaInfo{
+				CollectionSchema: &schemapb.CollectionSchema{
+					Functions: []*schemapb.FunctionSchema{
+						{Name: "test_function", Type: schemapb.FunctionType_TextEmbedding},
+						{Name: "f2", Type: schemapb.FunctionType_TextEmbedding},
+					},
+				},
+			},
+		}
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe()
+		m := mockey.Mock(validateFunction).Return(nil).Build()
+		defer m.UnPatch()
+		globalMetaCache = cache
+		err := task.PreExecute(ctx)
+		f.NoError(err)
+	}
+}
+
+func (f *FunctionTaskSuite) TestDropCollectionFunctionTaskPreExecute() {
+	ctx := context.Background()
+	{
+		// Test with valid request
+		req := &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_DropCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			FunctionName:   "test_function",
+		}
+
+		task := &dropCollectionFunctionTask{
+			Condition:                     NewTaskCondition(ctx),
+			DropCollectionFunctionRequest: req,
+		}
+
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, fmt.Errorf("mock error")).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.ErrorContains(err, "mock error")
+	}
+	{
+		req := &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_DropCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			FunctionName:   "test_function",
+		}
+
+		task := &dropCollectionFunctionTask{
+			Condition:                     NewTaskCondition(ctx),
+			DropCollectionFunctionRequest: req,
+		}
+
+		coll := &collectionInfo{
+			schema: &schemaInfo{
+				CollectionSchema: &schemapb.CollectionSchema{
+					Functions: []*schemapb.FunctionSchema{},
+				},
+			},
+		}
+
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.NoError(err)
+	}
+	{
+		req := &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_DropCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			FunctionName:   "test_function",
+		}
+
+		task := &dropCollectionFunctionTask{
+			Condition:                     NewTaskCondition(ctx),
+			DropCollectionFunctionRequest: req,
+		}
+
+		coll := &collectionInfo{
+			schema: &schemaInfo{
+				CollectionSchema: &schemapb.CollectionSchema{
+					Functions: []*schemapb.FunctionSchema{
+						{Name: req.FunctionName},
+					},
+				},
+			},
+		}
+
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe()
+		globalMetaCache = cache
+
+		err := task.PreExecute(ctx)
+		f.NoError(err)
+	}
+}
+
+func (f *FunctionTaskSuite) TestGetCollectionInfo() {
+	ctx := context.Background()
+	{
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, "db", "collection").Return(0, fmt.Errorf("Mock Error")).Maybe()
+		globalMetaCache = cache
+
+		_, err := getCollectionInfo(ctx, "db", "collection")
+		f.ErrorContains(err, "Mock Error")
+	}
+	{
+		cache := NewMockCache(f.T())
+		cache.EXPECT().GetCollectionID(ctx, "db", "collection").Return(int64(1), nil).Maybe()
+		cache.EXPECT().GetCollectionInfo(ctx, "db", "collection", int64(1)).Return(nil, fmt.Errorf("Mock info error")).Maybe()
+		globalMetaCache = cache
+
+		_, err := getCollectionInfo(ctx, "db", "collection")
+		f.ErrorContains(err, "Mock info error")
+	}
+}
+
+func (f *FunctionTaskSuite) TestAlterCollectionFunctionTaskExecute() {
+	ctx := context.Background()
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_BM25,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"sparse_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+			FunctionSchema: functionSchema,
+		}
+
+		mockRootCoord.EXPECT().AlterCollectionFunction(mock.Anything, req).Return(&commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+		}, nil)
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+			mixCoord:                       mockRootCoord,
+		}
+
+		err := task.Execute(ctx)
+		f.NoError(err)
+	}
+
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_BM25,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"sparse_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AlterCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+			FunctionSchema: functionSchema,
+		}
+
+		mockRootCoord.EXPECT().AlterCollectionFunction(mock.Anything, req).Return(&commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+			Reason:    "test error",
+		}, nil)
+
+		task := &alterCollectionFunctionTask{
+			Condition:                      NewTaskCondition(ctx),
+			AlterCollectionFunctionRequest: req,
+			mixCoord:                       mockRootCoord,
+		}
+		err := task.Execute(ctx)
+		f.Error(err)
+	}
+}
+
+func (f *FunctionTaskSuite) TestAddCollectionFunctionTaskExecute() {
+	ctx := context.Background()
+
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_BM25,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"sparse_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionSchema: functionSchema,
+		}
+
+		mockRootCoord.EXPECT().AddCollectionFunction(mock.Anything, req).Return(&commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+		}, nil)
+
+		task := &addCollectionFunctionTask{
+			Condition:                    NewTaskCondition(ctx),
+			AddCollectionFunctionRequest: req,
+			mixCoord:                     mockRootCoord,
+		}
+
+		err := task.Execute(ctx)
+		f.NoError(err)
+	}
+
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		functionSchema := &schemapb.FunctionSchema{
+			Name:             "test_function",
+			Type:             schemapb.FunctionType_BM25,
+			InputFieldNames:  []string{"text_field"},
+			OutputFieldNames: []string{"sparse_field"},
+			Params:           []*commonpb.KeyValuePair{},
+		}
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionSchema: functionSchema,
+		}
+
+		mockRootCoord.EXPECT().AddCollectionFunction(mock.Anything, req).Return(&commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+			Reason:    "test error",
+		}, nil)
+
+		task := &addCollectionFunctionTask{
+			Condition:                    NewTaskCondition(ctx),
+			AddCollectionFunctionRequest: req,
+			mixCoord:                     mockRootCoord,
+		}
+		err := task.Execute(ctx)
+		f.Error(err)
+	}
+}
+
+func (f *FunctionTaskSuite) TestDropCollectionFunctionTaskExecute() {
+	ctx := context.Background()
+
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		req := &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_DropCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+		}
+
+		mockRootCoord.EXPECT().DropCollectionFunction(mock.Anything, req).Return(&commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+		}, nil)
+
+		task := &dropCollectionFunctionTask{
+			Condition:                     NewTaskCondition(ctx),
+			DropCollectionFunctionRequest: req,
+			mixCoord:                      mockRootCoord,
+			fSchema: &schemapb.FunctionSchema{
+				Type: schemapb.FunctionType_TextEmbedding,
+			},
+		}
+
+		err := task.Execute(ctx)
+		f.NoError(err)
+	}
+
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		req := &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_DropCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+		}
+
+		mockRootCoord.EXPECT().DropCollectionFunction(mock.Anything, req).Return(&commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+			Reason:    "test error",
+		}, nil)
+
+		task := &dropCollectionFunctionTask{
+			Condition:                     NewTaskCondition(ctx),
+			DropCollectionFunctionRequest: req,
+			mixCoord:                      mockRootCoord,
+			fSchema: &schemapb.FunctionSchema{
+				Type: schemapb.FunctionType_TextEmbedding,
+			},
+		}
+
+		err := task.Execute(ctx)
+		f.Error(err)
+	}
+
+	{
+		mockRootCoord := mocks.NewMockMixCoordClient(f.T())
+
+		req := &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_DropCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test_function",
+		}
+
+		task := &dropCollectionFunctionTask{
+			Condition:                     NewTaskCondition(ctx),
+			DropCollectionFunctionRequest: req,
+			mixCoord:                      mockRootCoord,
+			fSchema: &schemapb.FunctionSchema{
+				Type: schemapb.FunctionType_BM25,
+			},
+		}
+
+		err := task.Execute(ctx)
+		f.ErrorContains(err, "Currently does not support droping BM25 function")
+	}
+}

internal/proxy/impl.go

@@ -1168,6 +1168,169 @@ func (node *Proxy) AlterCollection(ctx context.Context, request *milvuspb.AlterC
 	return act.result, nil
 }
 
+func (node *Proxy) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
+		return merr.Status(err), nil
+	}
+
+	ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-AddCollectionFunction")
+	defer sp.End()
+	method := "AddCollectionFunction"
+	tr := timerecord.NewTimeRecorder(method)
+	task := &addCollectionFunctionTask{
+		ctx:                          ctx,
+		Condition:                    NewTaskCondition(ctx),
+		AddCollectionFunctionRequest: request,
+		mixCoord:                     node.mixCoord,
+	}
+	log := log.Ctx(ctx).With(
+		zap.String("role", typeutil.ProxyRole),
+		zap.String("db", request.DbName),
+		zap.String("collection", request.CollectionName))
+
+	log.Info(rpcReceived(method))
+
+	if err := node.sched.ddQueue.Enqueue(task); err != nil {
+		log.Warn(
+			rpcFailedToEnqueue(method),
+			zap.Error(err))
+		return merr.Status(err), nil
+	}
+
+	log.Debug(
+		rpcEnqueued(method),
+		zap.Uint64("BeginTs", task.BeginTs()),
+		zap.Uint64("EndTs", task.EndTs()),
+		zap.Uint64("timestamp", request.Base.Timestamp))
+
+	if err := task.WaitToFinish(); err != nil {
+		log.Warn(
+			rpcFailedToWaitToFinish(method),
+			zap.Error(err),
+			zap.Uint64("BeginTs", task.BeginTs()),
+			zap.Uint64("EndTs", task.EndTs()))
+
+		return merr.Status(err), nil
+	}
+
+	log.Info(
+		rpcDone(method),
+		zap.Uint64("BeginTs", task.BeginTs()),
+		zap.Uint64("EndTs", task.EndTs()))
+
+	metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
+	return task.result, nil
+}
+
+func (node *Proxy) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
+		return merr.Status(err), nil
+	}
+
+	ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-AlterCollectionFunction")
+	defer sp.End()
+	method := "AlterCollectionFunction"
+	tr := timerecord.NewTimeRecorder(method)
+	task := &alterCollectionFunctionTask{
+		ctx:                            ctx,
+		Condition:                      NewTaskCondition(ctx),
+		AlterCollectionFunctionRequest: request,
+		mixCoord:                       node.mixCoord,
+	}
+	log := log.Ctx(ctx).With(
+		zap.String("role", typeutil.ProxyRole),
+		zap.String("db", request.DbName),
+		zap.String("collection", request.CollectionName),
+		zap.String("collection", request.FunctionName))
+
+	log.Info(rpcReceived(method))
+
+	if err := node.sched.ddQueue.Enqueue(task); err != nil {
+		log.Warn(
+			rpcFailedToEnqueue(method),
+			zap.Error(err))
+		return merr.Status(err), nil
+	}
+
+	log.Debug(
+		rpcEnqueued(method),
+		zap.Uint64("BeginTs", task.BeginTs()),
+		zap.Uint64("EndTs", task.EndTs()),
+		zap.Uint64("timestamp", request.Base.Timestamp))
+
+	if err := task.WaitToFinish(); err != nil {
+		log.Warn(
+			rpcFailedToWaitToFinish(method),
+			zap.Error(err),
+			zap.Uint64("BeginTs", task.BeginTs()),
+			zap.Uint64("EndTs", task.EndTs()))
+
+		return merr.Status(err), nil
+	}
+
+	log.Info(
+		rpcDone(method),
+		zap.Uint64("BeginTs", task.BeginTs()),
+		zap.Uint64("EndTs", task.EndTs()))
+
+	metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
+	return task.result, nil
+}
+
+func (node *Proxy) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
+		return merr.Status(err), nil
+	}
+
+	ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-DropCollectionFunction")
+	defer sp.End()
+	method := "DropCollectionFunction"
+	tr := timerecord.NewTimeRecorder(method)
+	task := &dropCollectionFunctionTask{
+		ctx:                           ctx,
+		Condition:                     NewTaskCondition(ctx),
+		DropCollectionFunctionRequest: request,
+		mixCoord:                      node.mixCoord,
+	}
+	log := log.Ctx(ctx).With(
+		zap.String("role", typeutil.ProxyRole),
+		zap.String("db", request.DbName),
+		zap.String("collection", request.CollectionName))
+
+	log.Info(rpcReceived(method))
+
+	if err := node.sched.ddQueue.Enqueue(task); err != nil {
+		log.Warn(
+			rpcFailedToEnqueue(method),
+			zap.Error(err))
+		return merr.Status(err), nil
+	}
+
+	log.Debug(
+		rpcEnqueued(method),
+		zap.Uint64("BeginTs", task.BeginTs()),
+		zap.Uint64("EndTs", task.EndTs()),
+		zap.Uint64("timestamp", request.Base.Timestamp))
+
+	if err := task.WaitToFinish(); err != nil {
+		log.Warn(
+			rpcFailedToWaitToFinish(method),
+			zap.Error(err),
+			zap.Uint64("BeginTs", task.BeginTs()),
+			zap.Uint64("EndTs", task.EndTs()))
+
+		return merr.Status(err), nil
+	}
+
+	log.Info(
+		rpcDone(method),
+		zap.Uint64("BeginTs", task.BeginTs()),
+		zap.Uint64("EndTs", task.EndTs()))
+
+	metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
+	return task.result, nil
+}
+
 func (node *Proxy) AlterCollectionField(ctx context.Context, request *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) {
 	if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
 		return merr.Status(err), nil

internal/proxy/impl_test.go

@@ -226,6 +226,84 @@ func TestProxyRenameCollection(t *testing.T) {
 	})
 }
 
+func TestProxyFunctionEdit(t *testing.T) {
+	mockey.PatchConvey("TestProxy_AddFunction", t, func() {
+		m1 := mockey.Mock((*ddTaskQueue).Enqueue).To(func(t task) error {
+			return nil
+		}).Build()
+		m2 := mockey.Mock((*TaskCondition).WaitToFinish).Return(nil).Build()
+		defer m1.UnPatch()
+		defer m2.UnPatch()
+		node := createTestProxy()
+		defer node.sched.Close()
+
+		_, err := node.AddCollectionFunction(context.Background(), &milvuspb.AddCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionSchema: &schemapb.FunctionSchema{
+				Name:             "test_function",
+				Type:             schemapb.FunctionType_TextEmbedding,
+				InputFieldNames:  []string{},
+				OutputFieldNames: []string{},
+				Params:           []*commonpb.KeyValuePair{},
+			},
+		})
+		assert.NoError(t, err)
+	})
+
+	mockey.PatchConvey("TestProxy_DropFunction", t, func() {
+		m1 := mockey.Mock((*ddTaskQueue).Enqueue).To(func(t task) error {
+			return nil
+		}).Build()
+		m2 := mockey.Mock((*TaskCondition).WaitToFinish).Return(nil).Build()
+		defer m1.UnPatch()
+		defer m2.UnPatch()
+		node := createTestProxy()
+		defer node.sched.Close()
+
+		_, err := node.DropCollectionFunction(context.Background(), &milvuspb.DropCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test",
+		})
+		assert.NoError(t, err)
+	})
+
+	mockey.PatchConvey("TestProxy_AlterFunction", t, func() {
+		m1 := mockey.Mock((*ddTaskQueue).Enqueue).To(func(t task) error {
+			return nil
+		}).Build()
+		m2 := mockey.Mock((*TaskCondition).WaitToFinish).Return(nil).Build()
+		defer m1.UnPatch()
+		defer m2.UnPatch()
+		node := createTestProxy()
+		defer node.sched.Close()
+
+		_, err := node.AlterCollectionFunction(context.Background(), &milvuspb.AlterCollectionFunctionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType: commonpb.MsgType_AddCollectionFunction,
+			},
+			CollectionName: "test_collection",
+			CollectionID:   1,
+			FunctionName:   "test",
+			FunctionSchema: &schemapb.FunctionSchema{
+				Name:             "test_function",
+				Type:             schemapb.FunctionType_TextEmbedding,
+				InputFieldNames:  []string{},
+				OutputFieldNames: []string{},
+				Params:           []*commonpb.KeyValuePair{},
+			},
+		})
+		assert.NoError(t, err)
+	})
+}
+
 func TestProxy_ResourceGroup(t *testing.T) {
 	factory := dependency.NewDefaultFactory(true)
 	ctx := context.Background()

internal/proxy/rootcoord_mock_test.go

@@ -1168,6 +1168,18 @@ func (coord *MixCoordMock) AlterCollectionField(ctx context.Context, request *mi
 	return &commonpb.Status{}, nil
 }
 
+func (coord *MixCoordMock) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	return &commonpb.Status{}, nil
+}
+
+func (coord *MixCoordMock) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	return &commonpb.Status{}, nil
+}
+
+func (coord *MixCoordMock) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	return &commonpb.Status{}, nil
+}
+
 func (coord *MixCoordMock) CreateDatabase(ctx context.Context, in *milvuspb.CreateDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	return &commonpb.Status{}, nil
 }

internal/proxy/task.go

@@ -104,6 +104,9 @@ const (
 	ListAliasesTaskName           = "ListAliasesTask"
 	AlterCollectionTaskName       = "AlterCollectionTask"
 	AlterCollectionFieldTaskName  = "AlterCollectionFieldTask"
+	AddCollectionFunctionTask     = "AddCollectionFunctionTask"
+	AlterCollectionFunctionTask   = "AlterCollectionFunctionTask"
+	DropCollectionFunctionTask    = "DropCollectionFunctionTask"
 	UpsertTaskName                = "UpsertTask"
 	CreateResourceGroupTaskName   = "CreateResourceGroupTask"
 	UpdateResourceGroupsTaskName  = "UpdateResourceGroupsTask"

internal/rootcoord/ddl_callbacks_collection_function.go

@@ -0,0 +1,275 @@
+// 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 rootcoord
+
+import (
+	"context"
+	"fmt"
+
+	"go.uber.org/zap"
+	"google.golang.org/protobuf/types/known/fieldmaskpb"
+
+	"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/distributed/streaming"
+	"github.com/milvus-io/milvus/internal/metastore/model"
+	"github.com/milvus-io/milvus/internal/streamingcoord/server/broadcaster"
+	"github.com/milvus-io/milvus/pkg/v2/log"
+	"github.com/milvus-io/milvus/pkg/v2/proto/messagespb"
+	"github.com/milvus-io/milvus/pkg/v2/streaming/util/message"
+	"github.com/milvus-io/milvus/pkg/v2/util/merr"
+	"github.com/milvus-io/milvus/pkg/v2/util/typeutil"
+)
+
+func callAlterCollection(ctx context.Context, c *Core, broadcaster broadcaster.BroadcastAPI, coll *model.Collection, dbName string, collectionName string) error {
+	// build new collection schema.
+	schema := &schemapb.CollectionSchema{
+		Name:               coll.Name,
+		Description:        coll.Description,
+		AutoID:             coll.AutoID,
+		Fields:             model.MarshalFieldModels(coll.Fields),
+		StructArrayFields:  model.MarshalStructArrayFieldModels(coll.StructArrayFields),
+		Functions:          model.MarshalFunctionModels(coll.Functions),
+		EnableDynamicField: coll.EnableDynamicField,
+		Properties:         coll.Properties,
+		Version:            coll.SchemaVersion + 1,
+	}
+
+	cacheExpirations, err := c.getCacheExpireForCollection(ctx, dbName, collectionName)
+	if err != nil {
+		return err
+	}
+
+	header := &messagespb.AlterCollectionMessageHeader{
+		DbId:         coll.DBID,
+		CollectionId: coll.CollectionID,
+		UpdateMask: &fieldmaskpb.FieldMask{
+			Paths: []string{message.FieldMaskCollectionSchema},
+		},
+		CacheExpirations: cacheExpirations,
+	}
+	body := &messagespb.AlterCollectionMessageBody{
+		Updates: &messagespb.AlterCollectionMessageUpdates{
+			Schema: schema,
+		},
+	}
+
+	channels := make([]string, 0, len(coll.VirtualChannelNames)+1)
+	channels = append(channels, streaming.WAL().ControlChannel())
+	channels = append(channels, coll.VirtualChannelNames...)
+	msg := message.NewAlterCollectionMessageBuilderV2().
+		WithHeader(header).
+		WithBody(body).
+		WithBroadcast(channels).
+		MustBuildBroadcast()
+	if _, err := broadcaster.Broadcast(ctx, msg); err != nil {
+		return err
+	}
+	return nil
+}
+
+func alterFunctionGenNewCollection(ctx context.Context, fSchema *schemapb.FunctionSchema, collection *model.Collection) error {
+	if fSchema == nil {
+		return fmt.Errorf("Function schema is empty")
+	}
+	var oldFuncSchema *model.Function
+	newFuncs := []*model.Function{}
+	for _, f := range collection.Functions {
+		if f.Name == fSchema.Name {
+			oldFuncSchema = f
+		} else {
+			newFuncs = append(newFuncs, f)
+		}
+	}
+	if oldFuncSchema == nil {
+		err := fmt.Errorf("Function %s not exists", fSchema.Name)
+		log.Ctx(ctx).Error("Alter function failed:", zap.Error(err))
+		return err
+	}
+
+	fSchema.Id = oldFuncSchema.ID
+
+	fieldMapping := map[string]*model.Field{}
+	for _, field := range collection.Fields {
+		fieldMapping[field.Name] = field
+	}
+
+	// reset output field info
+	for _, name := range oldFuncSchema.OutputFieldNames {
+		field, exists := fieldMapping[name]
+		if !exists {
+			return fmt.Errorf("Old version function's output field %s not exists", name)
+		}
+		field.IsFunctionOutput = false
+	}
+
+	for _, name := range fSchema.InputFieldNames {
+		field, exists := fieldMapping[name]
+		if !exists {
+			err := fmt.Errorf("function's input field %s not exists", name)
+			log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err))
+			return err
+		}
+		fSchema.InputFieldIds = append(fSchema.InputFieldIds, field.FieldID)
+	}
+	for _, name := range fSchema.OutputFieldNames {
+		field, exists := fieldMapping[name]
+		if !exists {
+			err := fmt.Errorf("function's output field %s not exists", name)
+			log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err))
+			return err
+		}
+		if field.IsFunctionOutput {
+			err := fmt.Errorf("function's output field %s is already of other functions", name)
+			log.Ctx(ctx).Error("Incorrect function configuration: ", zap.Error(err))
+			return err
+		}
+		fSchema.OutputFieldIds = append(fSchema.OutputFieldIds, field.FieldID)
+		field.IsFunctionOutput = true
+	}
+	newFunc := model.UnmarshalFunctionModel(fSchema)
+	newFuncs = append(newFuncs, newFunc)
+	collection.Functions = newFuncs
+	return nil
+}
+
+func (c *Core) broadcastAlterCollectionForAlterFunction(ctx context.Context, req *milvuspb.AlterCollectionFunctionRequest) error {
+	broadcaster, err := c.startBroadcastWithAliasOrCollectionLock(ctx, req.GetDbName(), req.GetCollectionName())
+	if err != nil {
+		return err
+	}
+	defer broadcaster.Close()
+
+	oldColl, err := c.meta.GetCollectionByName(ctx, req.GetDbName(), req.GetCollectionName(), typeutil.MaxTimestamp)
+	if err != nil {
+		return err
+	}
+
+	newColl := oldColl.Clone()
+	if err := alterFunctionGenNewCollection(ctx, req.FunctionSchema, newColl); err != nil {
+		return err
+	}
+
+	return callAlterCollection(ctx, c, broadcaster, newColl, req.GetDbName(), req.GetCollectionName())
+}
+
+func (c *Core) broadcastAlterCollectionForDropFunction(ctx context.Context, req *milvuspb.DropCollectionFunctionRequest) error {
+	broadcaster, err := c.startBroadcastWithAliasOrCollectionLock(ctx, req.GetDbName(), req.GetCollectionName())
+	if err != nil {
+		return err
+	}
+	defer broadcaster.Close()
+
+	oldColl, err := c.meta.GetCollectionByName(ctx, req.GetDbName(), req.GetCollectionName(), typeutil.MaxTimestamp)
+	if err != nil {
+		return err
+	}
+
+	var needDelFunc *model.Function
+	for _, f := range oldColl.Functions {
+		if f.Name == req.FunctionName {
+			needDelFunc = f
+			break
+		}
+	}
+	if needDelFunc == nil {
+		return nil
+	}
+
+	newColl := oldColl.Clone()
+
+	newFuncs := []*model.Function{}
+	for _, f := range newColl.Functions {
+		if f.Name != needDelFunc.Name {
+			newFuncs = append(newFuncs, f)
+		}
+	}
+	newColl.Functions = newFuncs
+
+	fieldMapping := map[int64]*model.Field{}
+	for _, field := range newColl.Fields {
+		fieldMapping[field.FieldID] = field
+	}
+	for _, id := range needDelFunc.OutputFieldIDs {
+		field, exists := fieldMapping[id]
+		if !exists {
+			return fmt.Errorf("function's output field %d not exists", id)
+		}
+		field.IsFunctionOutput = false
+	}
+	return callAlterCollection(ctx, c, broadcaster, newColl, req.GetDbName(), req.GetCollectionName())
+}
+
+func (c *Core) broadcastAlterCollectionForAddFunction(ctx context.Context, req *milvuspb.AddCollectionFunctionRequest) error {
+	broadcaster, err := c.startBroadcastWithAliasOrCollectionLock(ctx, req.GetDbName(), req.GetCollectionName())
+	if err != nil {
+		return err
+	}
+	defer broadcaster.Close()
+
+	oldColl, err := c.meta.GetCollectionByName(ctx, req.GetDbName(), req.GetCollectionName(), typeutil.MaxTimestamp)
+	if err != nil {
+		return err
+	}
+
+	newColl := oldColl.Clone()
+	fSchema := req.FunctionSchema
+	if fSchema == nil {
+		return merr.WrapErrParameterInvalidMsg("Function schema is empty")
+	}
+
+	nextFunctionID := int64(StartOfUserFunctionID)
+	for _, f := range newColl.Functions {
+		if f.Name == fSchema.Name {
+			return merr.WrapErrParameterInvalidMsg("function name already exists: %s", f.Name)
+		}
+		nextFunctionID = max(nextFunctionID, f.ID+1)
+	}
+	fSchema.Id = nextFunctionID
+
+	fieldMapping := map[string]*model.Field{}
+	for _, field := range newColl.Fields {
+		fieldMapping[field.Name] = field
+	}
+	for _, name := range fSchema.InputFieldNames {
+		field, exists := fieldMapping[name]
+		if !exists {
+			err := fmt.Errorf("function's input field %s not exists", name)
+			log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err))
+			return err
+		}
+		fSchema.InputFieldIds = append(fSchema.InputFieldIds, field.FieldID)
+	}
+	for _, name := range fSchema.OutputFieldNames {
+		field, exists := fieldMapping[name]
+		if !exists {
+			err := fmt.Errorf("function's output field %s not exists", name)
+			log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err))
+			return err
+		}
+		if field.IsFunctionOutput {
+			err := fmt.Errorf("function's output field %s is already of other functions", name)
+			log.Ctx(ctx).Error("Incorrect function configuration: ", zap.Error(err))
+			return err
+		}
+		fSchema.OutputFieldIds = append(fSchema.OutputFieldIds, field.FieldID)
+		field.IsFunctionOutput = true
+	}
+	newFunc := model.UnmarshalFunctionModel(fSchema)
+	newColl.Functions = append(newColl.Functions, newFunc)
+	return callAlterCollection(ctx, c, broadcaster, newColl, req.GetDbName(), req.GetCollectionName())
+}

internal/rootcoord/ddl_callbacks_collection_function_test.go

@@ -0,0 +1,596 @@
+// 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 rootcoord
+
+import (
+	"context"
+	"testing"
+
+	"github.com/bytedance/mockey"
+	"github.com/cockroachdb/errors"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	"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/metastore/model"
+	"github.com/milvus-io/milvus/internal/mocks/streamingcoord/server/mock_broadcaster"
+	mockrootcoord "github.com/milvus-io/milvus/internal/rootcoord/mocks"
+	"github.com/milvus-io/milvus/pkg/v2/streaming/util/message"
+	"github.com/milvus-io/milvus/pkg/v2/streaming/util/types"
+	"github.com/milvus-io/milvus/pkg/v2/util/typeutil"
+)
+
+type DDLCallbacksCollectionFunctionTestSuite struct {
+	suite.Suite
+	core            *Core
+	mockBroadcaster *mock_broadcaster.MockBroadcastAPI
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) SetupTest() {
+	suite.core = initStreamingSystemAndCore(suite.T())
+	suite.mockBroadcaster = mock_broadcaster.NewMockBroadcastAPI(suite.T())
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TearDownTest() {
+	suite.mockBroadcaster = nil
+	suite.core.Stop()
+	suite.core = nil
+}
+
+// Helper function to create a test collection
+func (suite *DDLCallbacksCollectionFunctionTestSuite) createTestCollection() *model.Collection {
+	return &model.Collection{
+		DBID:         1,
+		CollectionID: 100,
+		Name:         "test_collection",
+		Description:  "test collection",
+		AutoID:       true,
+		Fields: []*model.Field{
+			{
+				FieldID:          101,
+				Name:             "id",
+				IsPrimaryKey:     true,
+				AutoID:           true,
+				DataType:         schemapb.DataType_Int64,
+				IsFunctionOutput: false,
+			},
+			{
+				FieldID:          102,
+				Name:             "vector",
+				DataType:         schemapb.DataType_FloatVector,
+				IsFunctionOutput: false,
+			},
+			{
+				FieldID:          103,
+				Name:             "text_field",
+				DataType:         schemapb.DataType_VarChar,
+				IsFunctionOutput: false,
+			},
+			{
+				FieldID:          104,
+				Name:             "output_field",
+				DataType:         schemapb.DataType_FloatVector,
+				IsFunctionOutput: true,
+			},
+		},
+		Functions: []*model.Function{
+			{
+				ID:               1001,
+				Name:             "test_function",
+				Type:             schemapb.FunctionType_TextEmbedding,
+				Description:      "test function",
+				InputFieldIDs:    []int64{103},
+				InputFieldNames:  []string{"text_field"},
+				OutputFieldIDs:   []int64{104},
+				OutputFieldNames: []string{"output_field"},
+				Params: []*commonpb.KeyValuePair{
+					{Key: "param1", Value: "value1"},
+				},
+			},
+		},
+		VirtualChannelNames: []string{"test_channel"},
+		EnableDynamicField:  false,
+		Properties:          []*commonpb.KeyValuePair{{Key: "key1", Value: "value1"}},
+		SchemaVersion:       1,
+	}
+}
+
+// Helper function to create a test function schema
+func (suite *DDLCallbacksCollectionFunctionTestSuite) createTestFunctionSchema() *schemapb.FunctionSchema {
+	return &schemapb.FunctionSchema{
+		Name:             "new_function",
+		Type:             schemapb.FunctionType_TextEmbedding,
+		Description:      "new test function",
+		InputFieldNames:  []string{"text_field"},
+		OutputFieldNames: []string{"vector"},
+		Params: []*commonpb.KeyValuePair{
+			{Key: "param1", Value: "value1"},
+		},
+	}
+}
+
+func TestDDLCallbacksCollectionFunctionTestSuite(t *testing.T) {
+	suite.Run(t, new(DDLCallbacksCollectionFunctionTestSuite))
+}
+
+// Test callAlterCollection function
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestCallAlterCollection_Success() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+	dbName := "test_db"
+	collectionName := "test_collection"
+
+	// Create a test core with proper meta setup
+	core := newTestCore(withHealthyCode())
+	mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+	core.meta = mockMeta
+
+	// Mock meta calls for getCacheExpireForCollection
+	mockMeta.EXPECT().GetCollectionByName(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return(coll, nil)
+	mockMeta.EXPECT().ListAliases(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return([]string{}, nil)
+
+	// Mock broadcaster
+	suite.mockBroadcaster.EXPECT().Broadcast(mock.Anything, mock.MatchedBy(func(msg message.BroadcastMutableMessage) bool {
+		// Verify the message structure
+		return msg != nil
+	})).Return(&types.BroadcastAppendResult{}, nil)
+
+	err := callAlterCollection(ctx, core, suite.mockBroadcaster, coll, dbName, collectionName)
+	suite.NoError(err)
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestCallAlterCollection_GetCacheExpireFailed() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+	dbName := "test_db"
+	collectionName := "test_collection"
+
+	// Create a test core with proper meta setup
+	core := newTestCore(withHealthyCode())
+	mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+	core.meta = mockMeta
+
+	// Mock meta calls to return error
+	mockMeta.EXPECT().GetCollectionByName(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return(nil, errors.New("cache expire error"))
+
+	err := callAlterCollection(ctx, core, suite.mockBroadcaster, coll, dbName, collectionName)
+	suite.Error(err)
+	suite.Contains(err.Error(), "cache expire error")
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestCallAlterCollection_BroadcastFailed() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+	dbName := "test_db"
+	collectionName := "test_collection"
+
+	// Create a test core with proper meta setup
+	core := newTestCore(withHealthyCode())
+	mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+	core.meta = mockMeta
+
+	// Mock meta calls for getCacheExpireForCollection
+	mockMeta.EXPECT().GetCollectionByName(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return(coll, nil)
+	mockMeta.EXPECT().ListAliases(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return([]string{}, nil)
+
+	// Mock broadcaster to return error
+	suite.mockBroadcaster.EXPECT().Broadcast(mock.Anything, mock.Anything).Return(nil, errors.New("broadcast error"))
+
+	err := callAlterCollection(ctx, core, suite.mockBroadcaster, coll, dbName, collectionName)
+	suite.Error(err)
+	suite.Contains(err.Error(), "broadcast error")
+}
+
+// Test alterFunctionGenNewCollection function
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_Success() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+
+	// Create a function schema to alter existing function
+	fSchema := &schemapb.FunctionSchema{
+		Name:             "test_function", // Same name as existing function
+		Type:             schemapb.FunctionType_TextEmbedding,
+		Description:      "updated test function",
+		InputFieldNames:  []string{"text_field"},
+		OutputFieldNames: []string{"vector"}, // Different output field
+	}
+
+	err := alterFunctionGenNewCollection(ctx, fSchema, coll)
+	suite.NoError(err)
+
+	// Verify function ID is preserved
+	suite.Equal(int64(1001), fSchema.Id)
+
+	// Verify input field IDs are set
+	suite.Equal([]int64{103}, fSchema.InputFieldIds)
+
+	// Verify output field IDs are set
+	suite.Equal([]int64{102}, fSchema.OutputFieldIds)
+
+	// Verify old output field is no longer marked as function output
+	oldOutputField := coll.Fields[3] // output_field
+	suite.False(oldOutputField.IsFunctionOutput)
+
+	// Verify new output field is marked as function output
+	newOutputField := coll.Fields[1] // vector
+	suite.True(newOutputField.IsFunctionOutput)
+
+	// Verify function is added to collection
+	suite.Len(coll.Functions, 1) // Original + new
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_FunctionNotExists() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+
+	fSchema := &schemapb.FunctionSchema{
+		Name: "non_existent_function",
+	}
+
+	err := alterFunctionGenNewCollection(ctx, fSchema, coll)
+	suite.Error(err)
+	suite.Contains(err.Error(), "Function non_existent_function not exists")
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_InputFieldNotExists() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+
+	fSchema := &schemapb.FunctionSchema{
+		Name:            "test_function",
+		InputFieldNames: []string{"non_existent_field"},
+	}
+
+	err := alterFunctionGenNewCollection(ctx, fSchema, coll)
+	suite.Error(err)
+	suite.Contains(err.Error(), "function's input field non_existent_field not exists")
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_OutputFieldNotExists() {
+	ctx := context.Background()
+	coll := suite.createTestCollection()
+
+	fSchema := &schemapb.FunctionSchema{
+		Name:             "test_function",
+		InputFieldNames:  []string{"text_field"},
+		OutputFieldNames: []string{"non_existent_field"},
+	}
+
+	err := alterFunctionGenNewCollection(ctx, fSchema, coll)
+	suite.Error(err)
+	suite.Contains(err.Error(), "function's output field non_existent_field not exists")
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForAddFunction_FunctionNameExists() {
+	coll := suite.createTestCollection()
+
+	// Create request with existing function name
+	req := &milvuspb.AddCollectionFunctionRequest{
+		DbName:         "test_db",
+		CollectionName: "test_collection",
+		FunctionSchema: &schemapb.FunctionSchema{
+			Name: "test_function", // Same as existing function
+		},
+	}
+
+	newColl := coll.Clone()
+	fSchema := req.FunctionSchema
+
+	// Check for function name conflict
+	for _, f := range newColl.Functions {
+		if f.Name == fSchema.Name {
+			err := errors.New("function name already exists")
+			suite.Error(err)
+			return
+		}
+	}
+}
+
+// Test broadcastAlterCollectionForDropFunction
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction_Success() {
+	coll := suite.createTestCollection()
+	req := &milvuspb.DropCollectionFunctionRequest{
+		DbName:         "test_db",
+		CollectionName: "test_collection",
+		FunctionName:   "test_function",
+	}
+
+	// Find function to delete
+	var needDelFunc *model.Function
+	for _, f := range coll.Functions {
+		if f.Name == req.FunctionName {
+			needDelFunc = f
+			break
+		}
+	}
+	suite.NotNil(needDelFunc, "Function should exist")
+
+	newColl := coll.Clone()
+
+	// Remove function from collection
+	newFuncs := []*model.Function{}
+	for _, f := range newColl.Functions {
+		if f.Name != needDelFunc.Name {
+			newFuncs = append(newFuncs, f)
+		}
+	}
+	newColl.Functions = newFuncs
+
+	// Reset output field flags
+	fieldMapping := map[int64]*model.Field{}
+	for _, field := range newColl.Fields {
+		fieldMapping[field.FieldID] = field
+	}
+	for _, id := range needDelFunc.OutputFieldIDs {
+		field, exists := fieldMapping[id]
+		suite.True(exists, "Output field should exist")
+		field.IsFunctionOutput = false
+	}
+
+	// Verify function was removed
+	suite.Len(newColl.Functions, 0)
+
+	// Verify output field is no longer marked as function output
+	outputField := fieldMapping[104] // output_field
+	suite.False(outputField.IsFunctionOutput)
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction_FunctionNotExists() {
+	coll := suite.createTestCollection()
+	req := &milvuspb.DropCollectionFunctionRequest{
+		DbName:         "test_db",
+		CollectionName: "test_collection",
+		FunctionName:   "non_existent_function",
+	}
+
+	// Find function to delete
+	var needDelFunc *model.Function
+	for _, f := range coll.Functions {
+		if f.Name == req.FunctionName {
+			needDelFunc = f
+			break
+		}
+	}
+	suite.Nil(needDelFunc, "Function should not exist")
+	// This should return nil (no error) as per the original implementation
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction_OutputFieldNotExists() {
+	coll := suite.createTestCollection()
+
+	// Create a function with non-existent output field ID
+	needDelFunc := &model.Function{
+		ID:             1001,
+		Name:           "test_function",
+		OutputFieldIDs: []int64{999}, // Non-existent field ID
+	}
+
+	newColl := coll.Clone()
+	fieldMapping := map[int64]*model.Field{}
+	for _, field := range newColl.Fields {
+		fieldMapping[field.FieldID] = field
+	}
+
+	for _, id := range needDelFunc.OutputFieldIDs {
+		_, exists := fieldMapping[id]
+		if !exists {
+			err := errors.New("function's output field not exists")
+			suite.Error(err)
+			return
+		}
+	}
+}
+
+// Test edge cases and error conditions
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_OldOutputFieldNotExists() {
+	coll := suite.createTestCollection()
+
+	// Modify the existing function to have a non-existent output field
+	coll.Functions[0].OutputFieldNames = []string{"non_existent_output"}
+
+	fSchema := &schemapb.FunctionSchema{
+		Name:             "test_function",
+		InputFieldNames:  []string{"text_field"},
+		OutputFieldNames: []string{"vector"},
+	}
+
+	err := alterFunctionGenNewCollection(context.Background(), fSchema, coll)
+	suite.Error(err)
+	suite.Contains(err.Error(), "Old version function's output field non_existent_output not exists")
+}
+
+// Test with empty collections and functions
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_EmptyCollection() {
+	// Create collection with no functions
+	coll := &model.Collection{
+		Fields:    []*model.Field{},
+		Functions: []*model.Function{},
+	}
+
+	fSchema := &schemapb.FunctionSchema{
+		Name: "test_function",
+	}
+
+	err := alterFunctionGenNewCollection(context.Background(), fSchema, coll)
+	suite.Error(err)
+	suite.Contains(err.Error(), "Function test_function not exists")
+}
+
+// Test max function ID calculation
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAddFunction_NextFunctionIDCalculation() {
+	coll := suite.createTestCollection()
+
+	// Add more functions to test max ID calculation
+	coll.Functions = append(coll.Functions, &model.Function{
+		ID:   2000,
+		Name: "function2",
+	})
+	coll.Functions = append(coll.Functions, &model.Function{
+		ID:   1500,
+		Name: "function3",
+	})
+
+	nextFunctionID := int64(StartOfUserFunctionID)
+	for _, f := range coll.Functions {
+		nextFunctionID = max(nextFunctionID, f.ID+1)
+	}
+
+	suite.Equal(int64(2001), nextFunctionID)
+}
+
+// Test broadcastAlterCollectionForAlterFunction
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForAlterFunction() {
+	suite.Run("success", func() {
+		coll := suite.createTestCollection()
+
+		mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+		mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil)
+		suite.core.meta = mockMeta
+
+		req := &milvuspb.AlterCollectionFunctionRequest{
+			DbName:         "test_db",
+			CollectionName: "test_collection",
+			FunctionSchema: &schemapb.FunctionSchema{
+				Name:             "test_function",
+				Type:             schemapb.FunctionType_BM25,
+				InputFieldNames:  []string{"text_field"},
+				OutputFieldNames: []string{"vector"},
+			},
+		}
+		mocker := mockey.Mock(callAlterCollection).Return(nil).Build()
+		defer mocker.UnPatch()
+
+		err := suite.core.broadcastAlterCollectionForAlterFunction(context.Background(), req)
+		suite.NoError(err)
+	})
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction() {
+	suite.Run("success", func() {
+		coll := suite.createTestCollection()
+
+		mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+		mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil)
+		suite.core.meta = mockMeta
+
+		req := &milvuspb.DropCollectionFunctionRequest{
+			DbName:         "test_db",
+			CollectionName: "test_collection",
+			FunctionName:   "test_function",
+		}
+
+		mocker := mockey.Mock(callAlterCollection).Return(nil).Build()
+		defer mocker.UnPatch()
+
+		err := suite.core.broadcastAlterCollectionForDropFunction(context.Background(), req)
+		suite.NoError(err)
+	})
+
+	suite.Run("function not exists", func() {
+		req := &milvuspb.DropCollectionFunctionRequest{
+			DbName:         "test_db",
+			CollectionName: "test_collection",
+			FunctionName:   "non_existent_function",
+		}
+
+		mocker := mockey.Mock(callAlterCollection).Return(nil).Build()
+		defer mocker.UnPatch()
+
+		err := suite.core.broadcastAlterCollectionForDropFunction(context.Background(), req)
+		suite.NoError(err)
+	})
+}
+
+func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForAddFunction() {
+	suite.Run("function name already exists", func() {
+		coll := suite.createTestCollection()
+
+		mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+		mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil)
+		suite.core.meta = mockMeta
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			DbName:         "test_db",
+			CollectionName: "test_collection",
+			FunctionSchema: &schemapb.FunctionSchema{
+				Name:             "test_function",
+				Type:             schemapb.FunctionType_TextEmbedding,
+				InputFieldNames:  []string{"text_field"},
+				OutputFieldNames: []string{"vector"},
+			},
+		}
+
+		mocker := mockey.Mock(callAlterCollection).Return(nil).Build()
+		defer mocker.UnPatch()
+
+		err := suite.core.broadcastAlterCollectionForAddFunction(context.Background(), req)
+		suite.Error(err)
+	})
+
+	suite.Run("function input field not exists", func() {
+		coll := suite.createTestCollection()
+		mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+		mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil)
+		suite.core.meta = mockMeta
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			DbName:         "test_db",
+			CollectionName: "test_collection",
+			FunctionSchema: &schemapb.FunctionSchema{
+				Name:             "new_function",
+				Type:             schemapb.FunctionType_TextEmbedding,
+				InputFieldNames:  []string{"non_existent_field"},
+				OutputFieldNames: []string{"vector"},
+			},
+		}
+
+		mocker := mockey.Mock(callAlterCollection).Return(nil).Build()
+		defer mocker.UnPatch()
+
+		err := suite.core.broadcastAlterCollectionForAddFunction(context.Background(), req)
+		suite.Error(err)
+		suite.Contains(err.Error(), "function's input field non_existent_field not exists")
+	})
+
+	suite.Run("function output field not exists", func() {
+		coll := suite.createTestCollection()
+
+		mockMeta := mockrootcoord.NewIMetaTable(suite.T())
+		mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil)
+		suite.core.meta = mockMeta
+
+		req := &milvuspb.AddCollectionFunctionRequest{
+			DbName:         "test_db",
+			CollectionName: "test_collection",
+			FunctionSchema: &schemapb.FunctionSchema{
+				Name:             "new_function2",
+				Type:             schemapb.FunctionType_TextEmbedding,
+				InputFieldNames:  []string{"text_field"},
+				OutputFieldNames: []string{"non_existent_field"},
+			},
+		}
+
+		mocker := mockey.Mock(callAlterCollection).Return(nil).Build()
+		defer mocker.UnPatch()
+
+		err := suite.core.broadcastAlterCollectionForAddFunction(context.Background(), req)
+		suite.Error(err)
+		suite.Contains(err.Error(), "function's output field non_existent_field not exists")
+	})
+}

internal/rootcoord/meta_table_test.go

@@ -797,13 +797,14 @@ func TestMetaTable_AlterCollection(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 			mock.Anything,
+			mock.Anything,
 		).Return(errors.New("error"))
 		meta := &MetaTable{
 			catalog:     catalog,
 			collID2Meta: map[typeutil.UniqueID]*model.Collection{},
 		}
 		ctx := context.Background()
-		err := meta.AlterCollection(ctx, nil, nil, 0, false)
+		err := meta.AlterCollection(ctx, nil, nil, 0, false, false)
 		assert.Error(t, err)
 	})
 
@@ -839,6 +840,7 @@ func TestMetaTable_AlterCollection(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 			mock.Anything,
+			mock.Anything,
 		).Return(nil)
 		meta := &MetaTable{
 			catalog:     catalog,
@@ -848,7 +850,7 @@ func TestMetaTable_AlterCollection(t *testing.T) {
 
 		oldColl := &model.Collection{CollectionID: 1}
 		newColl := &model.Collection{CollectionID: 1}
-		err := meta.AlterCollection(ctx, oldColl, newColl, 0, false)
+		err := meta.AlterCollection(ctx, oldColl, newColl, 0, false, false)
 		assert.NoError(t, err)
 		assert.Equal(t, meta.collID2Meta[1], newColl)
 	})
@@ -1682,6 +1684,7 @@ func TestMetaTable_RenameCollection(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 			mock.Anything,
+			mock.Anything,
 		).Return(errors.New("fail"))
 
 		meta := &MetaTable{
@@ -1735,6 +1738,7 @@ func TestMetaTable_RenameCollection(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 			mock.Anything,
+			mock.Anything,
 		).Return(nil)
 		catalog.On("GetCollectionByName",
 			mock.Anything,
@@ -1779,6 +1783,7 @@ func TestMetaTable_RenameCollection(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 			mock.Anything,
+			mock.Anything,
 		).Return(nil)
 		catalog.On("GetCollectionByName",
 			mock.Anything,

internal/rootcoord/root_coord.go

@@ -1339,6 +1339,100 @@ func (c *Core) AlterCollection(ctx context.Context, in *milvuspb.AlterCollection
 	return merr.Success(), nil
 }
 
+func (c *Core) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	if err := merr.CheckHealthy(c.GetStateCode()); err != nil {
+		return merr.Status(err), nil
+	}
+
+	metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.TotalLabel).Inc()
+	tr := timerecord.NewTimeRecorder("AddCollectionFunction")
+
+	log := log.Ctx(ctx).With(zap.String("role", typeutil.RootCoordRole),
+		zap.String("dbName", in.GetDbName()),
+		zap.String("collectionName", in.GetCollectionName()),
+	)
+	log.Info("received request to Add collection function")
+
+	if err := c.broadcastAlterCollectionForAddFunction(ctx, in); err != nil {
+		if errors.Is(err, errIgnoredAlterCollection) {
+			log.Info("add collection function make no changes, ignore it")
+			metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.SuccessLabel).Inc()
+			return merr.Success(), nil
+		}
+		log.Warn("failed to alter collection function", zap.Error(err))
+		metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.FailLabel).Inc()
+		return merr.Status(err), nil
+	}
+
+	metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.SuccessLabel).Inc()
+	metrics.RootCoordDDLReqLatency.WithLabelValues("AddCollectionFunction").Observe(float64(tr.ElapseSpan().Milliseconds()))
+	log.Info("done to add collection function")
+	return merr.Success(), nil
+}
+
+func (c *Core) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	if err := merr.CheckHealthy(c.GetStateCode()); err != nil {
+		return merr.Status(err), nil
+	}
+
+	metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.TotalLabel).Inc()
+	tr := timerecord.NewTimeRecorder("AlterCollectionFunction")
+
+	log := log.Ctx(ctx).With(zap.String("role", typeutil.RootCoordRole),
+		zap.String("dbName", in.GetDbName()),
+		zap.String("collectionName", in.GetCollectionName()),
+	)
+	log.Info("received request to alter collection function")
+
+	if err := c.broadcastAlterCollectionForAlterFunction(ctx, in); err != nil {
+		if errors.Is(err, errIgnoredAlterCollection) {
+			log.Info("alter collection function make no changes, ignore it")
+			metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.SuccessLabel).Inc()
+			return merr.Success(), nil
+		}
+		log.Warn("failed to alter collection function", zap.Error(err))
+		metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.FailLabel).Inc()
+		return merr.Status(err), nil
+	}
+
+	metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.SuccessLabel).Inc()
+	metrics.RootCoordDDLReqLatency.WithLabelValues("AlterCollectionFunction").Observe(float64(tr.ElapseSpan().Milliseconds()))
+	log.Info("done to alter collection function")
+	return merr.Success(), nil
+}
+
+func (c *Core) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	if err := merr.CheckHealthy(c.GetStateCode()); err != nil {
+		return merr.Status(err), nil
+	}
+
+	metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.TotalLabel).Inc()
+	tr := timerecord.NewTimeRecorder("DropCollectionFunction")
+
+	log := log.Ctx(ctx).With(zap.String("role", typeutil.RootCoordRole),
+		zap.String("dbName", in.GetDbName()),
+		zap.String("collectionName", in.GetCollectionName()),
+		zap.String("functionName", in.GetFunctionName()),
+	)
+	log.Info("received request to drop collection function")
+
+	if err := c.broadcastAlterCollectionForDropFunction(ctx, in); err != nil {
+		if errors.Is(err, errIgnoredAlterCollection) {
+			log.Info("Drop collection function make no changes, ignore it")
+			metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.SuccessLabel).Inc()
+			return merr.Success(), nil
+		}
+		log.Warn("failed to drop collection function", zap.Error(err))
+		metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.FailLabel).Inc()
+		return merr.Status(err), nil
+	}
+
+	metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.SuccessLabel).Inc()
+	metrics.RootCoordDDLReqLatency.WithLabelValues("DropCollectionFunction").Observe(float64(tr.ElapseSpan().Milliseconds()))
+	log.Info("done to drop collection function")
+	return merr.Success(), nil
+}
+
 func (c *Core) AlterCollectionField(ctx context.Context, in *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) {
 	if err := merr.CheckHealthy(c.GetStateCode()); err != nil {
 		return merr.Status(err), nil

internal/rootcoord/root_coord_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/bytedance/mockey"
 	"github.com/cockroachdb/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -1266,6 +1267,102 @@ func TestRootCoord_AlterCollection(t *testing.T) {
 	})
 }
 
+func TestRootCoord_AddCollectionFunction(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		ctx := context.Background()
+		c := newTestCore(withAbnormalCode())
+		resp, err := c.AddCollectionFunction(ctx, &milvuspb.AddCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
+	})
+
+	t.Run("run ok", func(t *testing.T) {
+		ctx := context.Background()
+		c := initStreamingSystemAndCore(t)
+		defer c.Stop()
+		mocker := mockey.Mock((*Core).broadcastAlterCollectionForAddFunction).Return(nil).Build()
+		defer mocker.UnPatch()
+		resp, err := c.AddCollectionFunction(ctx, &milvuspb.AddCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
+	})
+
+	t.Run("run failed", func(t *testing.T) {
+		ctx := context.Background()
+		c := initStreamingSystemAndCore(t)
+		defer c.Stop()
+		mocker := mockey.Mock((*Core).broadcastAlterCollectionForAddFunction).Return(fmt.Errorf("")).Build()
+		defer mocker.UnPatch()
+		resp, err := c.AddCollectionFunction(ctx, &milvuspb.AddCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
+	})
+}
+
+func TestRootCoord_DropCollectionFunction(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		ctx := context.Background()
+		c := newTestCore(withAbnormalCode())
+		resp, err := c.DropCollectionFunction(ctx, &milvuspb.DropCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
+	})
+
+	t.Run("run ok", func(t *testing.T) {
+		ctx := context.Background()
+		c := initStreamingSystemAndCore(t)
+		defer c.Stop()
+		mocker := mockey.Mock((*Core).broadcastAlterCollectionForDropFunction).Return(nil).Build()
+		defer mocker.UnPatch()
+		resp, err := c.DropCollectionFunction(ctx, &milvuspb.DropCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
+	})
+
+	t.Run("run failed", func(t *testing.T) {
+		ctx := context.Background()
+		c := initStreamingSystemAndCore(t)
+		defer c.Stop()
+		mocker := mockey.Mock((*Core).broadcastAlterCollectionForDropFunction).Return(fmt.Errorf("")).Build()
+		defer mocker.UnPatch()
+		resp, err := c.DropCollectionFunction(ctx, &milvuspb.DropCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
+	})
+}
+
+func TestRootCoord_AlterCollectionFunction(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		ctx := context.Background()
+		c := newTestCore(withAbnormalCode())
+		resp, err := c.AlterCollectionFunction(ctx, &milvuspb.AlterCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
+	})
+
+	t.Run("run ok", func(t *testing.T) {
+		ctx := context.Background()
+		c := initStreamingSystemAndCore(t)
+		defer c.Stop()
+		mocker := mockey.Mock((*Core).broadcastAlterCollectionForAlterFunction).Return(nil).Build()
+		defer mocker.UnPatch()
+		resp, err := c.AlterCollectionFunction(ctx, &milvuspb.AlterCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
+	})
+
+	t.Run("run failed", func(t *testing.T) {
+		ctx := context.Background()
+		c := initStreamingSystemAndCore(t)
+		defer c.Stop()
+		mocker := mockey.Mock((*Core).broadcastAlterCollectionForAlterFunction).Return(fmt.Errorf("")).Build()
+		defer mocker.UnPatch()
+		resp, err := c.AlterCollectionFunction(ctx, &milvuspb.AlterCollectionFunctionRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
+	})
+}
+
 func TestRootCoord_CheckHealth(t *testing.T) {
 	// getQueryCoordMetricsFunc := func(tt typeutil.Timestamp) (*milvuspb.GetMetricsResponse, error) {
 	// 	clusterTopology := metricsinfo.QueryClusterTopology{

internal/util/function/embedding/text_embedding_function.go

@@ -108,7 +108,6 @@ func NewTextEmbeddingFunction(coll *schemapb.CollectionSchema, functionSchema *s
 	if err := TextEmbeddingOutputsCheck(base.outputFields); err != nil {
 		return nil, err
 	}
-
 	var embP textEmbeddingProvider
 	var newProviderErr error
 	conf := paramtable.Get().FunctionCfg.GetTextEmbeddingProviderConfig(base.provider)

internal/util/mock/grpc_rootcoord_client.go

@@ -274,6 +274,18 @@ func (m *GrpcRootCoordClient) AlterCollectionField(ctx context.Context, in *milv
 	return &commonpb.Status{}, m.Err
 }
 
+func (m *GrpcRootCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	return &commonpb.Status{}, m.Err
+}
+
+func (m *GrpcRootCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	return &commonpb.Status{}, m.Err
+}
+
+func (m *GrpcRootCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	return &commonpb.Status{}, m.Err
+}
+
 func (m *GrpcRootCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	return &commonpb.Status{}, m.Err
 }

pkg/proto/root_coord.proto

@@ -77,6 +77,12 @@ service RootCoord {
     rpc AlterCollection(milvus.AlterCollectionRequest) returns (common.Status) {}
     
     rpc AlterCollectionField(milvus.AlterCollectionFieldRequest) returns (common.Status) {}
+
+    rpc AddCollectionFunction(milvus.AddCollectionFunctionRequest) returns (common.Status) {}
+
+    rpc AlterCollectionFunction(milvus.AlterCollectionFunctionRequest) returns (common.Status) {}    
+    
+    rpc DropCollectionFunction(milvus.DropCollectionFunctionRequest) returns (common.Status) {}    
   /**
    * @brief This method is used to create partition
    *

pkg/proto/rootcoordpb/root_coord.pb.go

@@ -1466,7 +1466,7 @@ var file_root_coord_proto_rawDesc = []byte{
 	0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
 	0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x42, 0x43,
 	0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0d, 0x64, 0x62, 0x43, 0x6f,
-	0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x32, 0xc1, 0x2e, 0x0a, 0x09, 0x52, 0x6f,
+	0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x32, 0x88, 0x31, 0x0a, 0x09, 0x52, 0x6f,
 	0x6f, 0x74, 0x43, 0x6f, 0x6f, 0x72, 0x64, 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,
@@ -1584,265 +1584,286 @@ var file_root_coord_proto_rawDesc = []byte{
 	0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x65, 0x6c, 0x64,
 	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, 0x12, 0x5d, 0x0a, 0x0f, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
-	0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 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, 0x12, 0x59, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x72,
-	0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f,
-	0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 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,
-	0x12, 0x5d, 0x0a, 0x0c, 0x48, 0x61, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-	0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x48, 0x61, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74,
-	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6c,
-	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
-	0x6b, 0x0a, 0x0e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e,
-	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c,
-	0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x73, 0x0a, 0x16,
-	0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x49, 0x6e,
-	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f,
-	0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72,
-	0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x00, 0x12, 0x65, 0x0a, 0x0c, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74,
-	0x73, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d,
-	0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
-	0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x74, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x50,
-	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2e, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63,
-	0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c,
-	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63,
-	0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c,
-	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x71,
-	0x0a, 0x0e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
-	0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-	0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54,
-	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
-	0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x00, 0x12, 0x5c, 0x0a, 0x07, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x12, 0x26, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74,
-	0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c,
-	0x6c, 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
-	0x61, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c,
-	0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
-	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
-	0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b,
-	0x4d, 0x73, 0x67, 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, 0x12, 0x72, 0x0a, 0x1d, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65,
-	0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x43, 0x61,
-	0x63, 0x68, 0x65, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x4d, 0x65, 0x74, 0x61, 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, 0x12, 0x7b, 0x0a, 0x12, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f,
-	0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65,
-	0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
-	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
-	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69,
-	0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63,
-	0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69,
-	0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
-	0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x72,
-	0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
-	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
-	0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 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, 0x12, 0x58,
-	0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69,
-	0x61, 0x6c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65,
-	0x6e, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 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, 0x12, 0x5f, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65,
-	0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
-	0x75, 0x73, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74,
-	0x69, 0x61, 0x6c, 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, 0x12, 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73,
-	0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c,
-	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74,
-	0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x00, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e,
-	0x74, 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65,
-	0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x43,
-	0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c,
-	0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f,
-	0x6c, 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, 0x12, 0x4f, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70,
-	0x52, 0x6f, 0x6c, 0x65, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52,
-	0x6f, 0x6c, 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, 0x12, 0x5d, 0x0a, 0x0f, 0x4f, 0x70, 0x65,
-	0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x2b, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
-	0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f,
-	0x6c, 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, 0x12, 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, 0x65,
-	0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c,
-	0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c,
-	0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65,
-	0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x4f, 0x70,
-	0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x12, 0x2c,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76,
-	0x69, 0x6c, 0x65, 0x67, 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, 0x12, 0x62, 0x0a, 0x0b, 0x53,
-	0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c,
-	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 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, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
-	0x47, 0x72, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
-	0x63, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x28, 0x2e,
-	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74,
-	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e,
-	0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x00, 0x12, 0x67, 0x0a, 0x0a, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42,
-	0x41, 0x43, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52,
-	0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x4d,
-	0x65, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x59, 0x0a,
-	0x0b, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x42, 0x41, 0x43, 0x12, 0x2b, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
-	0x75, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65,
-	0x74, 0x61, 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, 0x12, 0x67, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61,
-	0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70,
-	0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69,
-	0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x43, 0x6f, 0x6c,
+	0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12,
+	0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d,
+	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
+	0x69, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 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, 0x12, 0x63, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65,
-	0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72,
-	0x6f, 0x70, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70,
-	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, 0x12, 0x7a, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72,
-	0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x2f, 0x2e,
-	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c,
-	0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67,
-	0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30,
-	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65,
-	0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x00, 0x12, 0x69, 0x0a, 0x15, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69,
-	0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x31, 0x2e, 0x6d, 0x69,
-	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
-	0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65,
-	0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 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, 0x12, 0x62, 0x0a,
-	0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x27, 0x2e, 0x6d,
+	0x00, 0x12, 0x6d, 0x0a, 0x17, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x6d,
 	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
-	0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65,
-	0x71, 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, 0x43, 0x68, 0x65, 0x63,
-	0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x00, 0x12, 0x5f, 0x0a, 0x10, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
-	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x52, 0x65, 0x6e, 0x61,
-	0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 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, 0x12, 0x5b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61,
-	0x62, 0x61, 0x73, 0x65, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74,
-	0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x75, 0x73, 0x2e, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 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,
+	0x12, 0x6b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
+	0x2e, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46,
+	0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 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, 0x12, 0x5d, 0x0a,
+	0x0f, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 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, 0x12, 0x59, 0x0a, 0x0d,
+	0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f,
+	0x6e, 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, 0x12, 0x5d, 0x0a, 0x0c, 0x48, 0x61, 0x73, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x48, 0x61,
+	0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6b, 0x0a, 0x0e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53,
+	0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50,
+	0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x00, 0x12, 0x73, 0x0a, 0x16, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x12, 0x2a, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
+	0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
+	0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x65, 0x0a, 0x0c, 0x53, 0x68, 0x6f, 0x77,
+	0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53,
+	0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67,
+	0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
+	0x74, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e,
+	0x66, 0x6f, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50,
+	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50,
+	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x71, 0x0a, 0x0e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+	0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e,
+	0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x07, 0x41, 0x6c, 0x6c, 0x6f,
+	0x63, 0x49, 0x44, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c,
+	0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63,
+	0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x61, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
+	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x12,
+	0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69,
+	0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54,
+	0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x4d, 0x73, 0x67, 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, 0x12, 0x72, 0x0a, 0x1d, 0x49, 0x6e, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x4d, 0x65, 0x74, 0x61, 0x43, 0x61, 0x63, 0x68, 0x65, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e,
+	0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x4d, 0x65,
+	0x74, 0x61, 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, 0x12, 0x7b, 0x0a,
+	0x12, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68,
+	0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65,
+	0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47,
+	0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x10, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12,
+	0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69,
+	0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69,
+	0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 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, 0x12, 0x58, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43,
+	0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
+	0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
+	0x6c, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f,
 	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, 0x12,
-	0x57, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12,
-	0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61,
-	0x73, 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, 0x12, 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74,
-	0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
+	0x5f, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74,
+	0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
+	0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 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,
+	0x12, 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72,
+	0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64,
+	0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d,
+	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
+	0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65,
+	0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63,
+	0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69,
+	0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
+	0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f,
+	0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x0a, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 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, 0x12,
+	0x4f, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x24, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x6f, 0x6c, 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,
+	0x12, 0x5d, 0x0a, 0x0f, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52,
+	0x6f, 0x6c, 0x65, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74,
+	0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 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, 0x12,
+	0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x26, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c,
+	0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65,
+	0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
+	0x12, 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x26,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c,
+	0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x00, 0x12, 0x5f, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76,
+	0x69, 0x6c, 0x65, 0x67, 0x65, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72,
+	0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 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, 0x12, 0x62, 0x0a, 0x0b, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e,
+	0x74, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72,
+	0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 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, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f,
+	0x6c, 0x69, 0x63, 0x79, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4c, 0x69, 0x73,
+	0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63,
+	0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x67, 0x0a, 0x0a, 0x42,
+	0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
 	0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x44,
-	0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x00, 0x12, 0x77, 0x0a, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61,
-	0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64,
-	0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0d, 0x41,
-	0x6c, 0x74, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2c, 0x2e, 0x6d,
-	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74,
-	0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62,
-	0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c,
+	0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x61, 0x63, 0x6b,
+	0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x59, 0x0a, 0x0b, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x52,
+	0x42, 0x41, 0x43, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72,
+	0x65, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 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, 0x12,
+	0x67, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65,
+	0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 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, 0x12, 0x63, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70,
+	0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2e,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65,
+	0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 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, 0x12, 0x7a, 0x0a,
+	0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x73, 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50,
+	0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74,
+	0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x15, 0x4f, 0x70, 0x65,
+	0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 0x12, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65,
+	0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 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, 0x12, 0x62, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61,
+	0x6c, 0x74, 0x68, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48,
+	0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 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, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x52, 0x65, 0x6e, 0x61,
+	0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x6d,
+	0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76,
+	0x75, 0x73, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
+	0x69, 0x6f, 0x6e, 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, 0x12, 0x72, 0x0a, 0x0f, 0x47, 0x65, 0x74,
-	0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 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, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74,
-	0x72, 0x69, 0x63, 0x73, 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, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72,
-	0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x36, 0x5a,
-	0x34, 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, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f,
-	0x6f, 0x72, 0x64, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x0e, 0x43, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2a, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 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, 0x12, 0x57, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x44, 0x61,
+	0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f,
+	0x70, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 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, 0x12,
+	0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73,
+	0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62,
+	0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69,
+	0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75,
+	0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x77, 0x0a, 0x10, 0x44, 0x65, 0x73,
+	0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2f, 0x2e,
+	0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f,
+	0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44,
+	0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30,
+	0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f,
+	0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65,
+	0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0d, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62,
+	0x61, 0x73, 0x65, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x74,
+	0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 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,
+	0x12, 0x72, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72,
+	0x69, 0x63, 0x73, 0x12, 0x2d, 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, 0x51,
+	0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 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, 0x51, 0x75,
+	0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x42, 0x36, 0x5a, 0x34, 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, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1859,103 +1880,106 @@ func file_root_coord_proto_rawDescGZIP() []byte {
 
 var file_root_coord_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
 var file_root_coord_proto_goTypes = []interface{}{
-	(*AllocTimestampRequest)(nil),                  // 0: milvus.proto.rootcoord.AllocTimestampRequest
-	(*AllocTimestampResponse)(nil),                 // 1: milvus.proto.rootcoord.AllocTimestampResponse
-	(*AllocIDRequest)(nil),                         // 2: milvus.proto.rootcoord.AllocIDRequest
-	(*AllocIDResponse)(nil),                        // 3: milvus.proto.rootcoord.AllocIDResponse
-	(*DescribeSegmentsRequest)(nil),                // 4: milvus.proto.rootcoord.DescribeSegmentsRequest
-	(*SegmentBaseInfo)(nil),                        // 5: milvus.proto.rootcoord.SegmentBaseInfo
-	(*SegmentInfos)(nil),                           // 6: milvus.proto.rootcoord.SegmentInfos
-	(*DescribeSegmentsResponse)(nil),               // 7: milvus.proto.rootcoord.DescribeSegmentsResponse
-	(*GetCredentialRequest)(nil),                   // 8: milvus.proto.rootcoord.GetCredentialRequest
-	(*GetCredentialResponse)(nil),                  // 9: milvus.proto.rootcoord.GetCredentialResponse
-	(*DescribeDatabaseRequest)(nil),                // 10: milvus.proto.rootcoord.DescribeDatabaseRequest
-	(*DescribeDatabaseResponse)(nil),               // 11: milvus.proto.rootcoord.DescribeDatabaseResponse
-	(*AlterDatabaseRequest)(nil),                   // 12: milvus.proto.rootcoord.AlterDatabaseRequest
-	(*GetPChannelInfoRequest)(nil),                 // 13: milvus.proto.rootcoord.GetPChannelInfoRequest
-	(*GetPChannelInfoResponse)(nil),                // 14: milvus.proto.rootcoord.GetPChannelInfoResponse
-	(*CollectionInfoOnPChannel)(nil),               // 15: milvus.proto.rootcoord.CollectionInfoOnPChannel
-	(*PartitionInfoOnPChannel)(nil),                // 16: milvus.proto.rootcoord.PartitionInfoOnPChannel
-	(*ShowCollectionIDsRequest)(nil),               // 17: milvus.proto.rootcoord.ShowCollectionIDsRequest
-	(*DBCollections)(nil),                          // 18: milvus.proto.rootcoord.DBCollections
-	(*ShowCollectionIDsResponse)(nil),              // 19: milvus.proto.rootcoord.ShowCollectionIDsResponse
-	nil,                                            // 20: milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry
-	nil,                                            // 21: milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry
-	(*commonpb.MsgBase)(nil),                       // 22: milvus.proto.common.MsgBase
-	(*commonpb.Status)(nil),                        // 23: milvus.proto.common.Status
-	(*etcdpb.SegmentIndexInfo)(nil),                // 24: milvus.proto.etcd.SegmentIndexInfo
-	(*commonpb.KeyValuePair)(nil),                  // 25: milvus.proto.common.KeyValuePair
-	(etcdpb.CollectionState)(0),                    // 26: milvus.proto.etcd.CollectionState
-	(*etcdpb.IndexInfo)(nil),                       // 27: milvus.proto.etcd.IndexInfo
-	(*milvuspb.GetComponentStatesRequest)(nil),     // 28: milvus.proto.milvus.GetComponentStatesRequest
-	(*internalpb.GetTimeTickChannelRequest)(nil),   // 29: milvus.proto.internal.GetTimeTickChannelRequest
-	(*internalpb.GetStatisticsChannelRequest)(nil), // 30: milvus.proto.internal.GetStatisticsChannelRequest
-	(*milvuspb.CreateCollectionRequest)(nil),       // 31: milvus.proto.milvus.CreateCollectionRequest
-	(*milvuspb.DropCollectionRequest)(nil),         // 32: milvus.proto.milvus.DropCollectionRequest
-	(*milvuspb.AddCollectionFieldRequest)(nil),     // 33: milvus.proto.milvus.AddCollectionFieldRequest
-	(*milvuspb.HasCollectionRequest)(nil),          // 34: milvus.proto.milvus.HasCollectionRequest
-	(*milvuspb.DescribeCollectionRequest)(nil),     // 35: milvus.proto.milvus.DescribeCollectionRequest
-	(*milvuspb.CreateAliasRequest)(nil),            // 36: milvus.proto.milvus.CreateAliasRequest
-	(*milvuspb.DropAliasRequest)(nil),              // 37: milvus.proto.milvus.DropAliasRequest
-	(*milvuspb.AlterAliasRequest)(nil),             // 38: milvus.proto.milvus.AlterAliasRequest
-	(*milvuspb.DescribeAliasRequest)(nil),          // 39: milvus.proto.milvus.DescribeAliasRequest
-	(*milvuspb.ListAliasesRequest)(nil),            // 40: milvus.proto.milvus.ListAliasesRequest
-	(*milvuspb.ShowCollectionsRequest)(nil),        // 41: milvus.proto.milvus.ShowCollectionsRequest
-	(*milvuspb.AlterCollectionRequest)(nil),        // 42: milvus.proto.milvus.AlterCollectionRequest
-	(*milvuspb.AlterCollectionFieldRequest)(nil),   // 43: milvus.proto.milvus.AlterCollectionFieldRequest
-	(*milvuspb.CreatePartitionRequest)(nil),        // 44: milvus.proto.milvus.CreatePartitionRequest
-	(*milvuspb.DropPartitionRequest)(nil),          // 45: milvus.proto.milvus.DropPartitionRequest
-	(*milvuspb.HasPartitionRequest)(nil),           // 46: milvus.proto.milvus.HasPartitionRequest
-	(*milvuspb.ShowPartitionsRequest)(nil),         // 47: milvus.proto.milvus.ShowPartitionsRequest
-	(*milvuspb.ShowSegmentsRequest)(nil),           // 48: milvus.proto.milvus.ShowSegmentsRequest
-	(*internalpb.ChannelTimeTickMsg)(nil),          // 49: milvus.proto.internal.ChannelTimeTickMsg
-	(*proxypb.InvalidateCollMetaCacheRequest)(nil), // 50: milvus.proto.proxy.InvalidateCollMetaCacheRequest
-	(*internalpb.ShowConfigurationsRequest)(nil),   // 51: milvus.proto.internal.ShowConfigurationsRequest
-	(*milvuspb.GetMetricsRequest)(nil),             // 52: milvus.proto.milvus.GetMetricsRequest
-	(*internalpb.CredentialInfo)(nil),              // 53: milvus.proto.internal.CredentialInfo
-	(*milvuspb.DeleteCredentialRequest)(nil),       // 54: milvus.proto.milvus.DeleteCredentialRequest
-	(*milvuspb.ListCredUsersRequest)(nil),          // 55: milvus.proto.milvus.ListCredUsersRequest
-	(*milvuspb.CreateRoleRequest)(nil),             // 56: milvus.proto.milvus.CreateRoleRequest
-	(*milvuspb.DropRoleRequest)(nil),               // 57: milvus.proto.milvus.DropRoleRequest
-	(*milvuspb.OperateUserRoleRequest)(nil),        // 58: milvus.proto.milvus.OperateUserRoleRequest
-	(*milvuspb.SelectRoleRequest)(nil),             // 59: milvus.proto.milvus.SelectRoleRequest
-	(*milvuspb.SelectUserRequest)(nil),             // 60: milvus.proto.milvus.SelectUserRequest
-	(*milvuspb.OperatePrivilegeRequest)(nil),       // 61: milvus.proto.milvus.OperatePrivilegeRequest
-	(*milvuspb.SelectGrantRequest)(nil),            // 62: milvus.proto.milvus.SelectGrantRequest
-	(*internalpb.ListPolicyRequest)(nil),           // 63: milvus.proto.internal.ListPolicyRequest
-	(*milvuspb.BackupRBACMetaRequest)(nil),         // 64: milvus.proto.milvus.BackupRBACMetaRequest
-	(*milvuspb.RestoreRBACMetaRequest)(nil),        // 65: milvus.proto.milvus.RestoreRBACMetaRequest
-	(*milvuspb.CreatePrivilegeGroupRequest)(nil),   // 66: milvus.proto.milvus.CreatePrivilegeGroupRequest
-	(*milvuspb.DropPrivilegeGroupRequest)(nil),     // 67: milvus.proto.milvus.DropPrivilegeGroupRequest
-	(*milvuspb.ListPrivilegeGroupsRequest)(nil),    // 68: milvus.proto.milvus.ListPrivilegeGroupsRequest
-	(*milvuspb.OperatePrivilegeGroupRequest)(nil),  // 69: milvus.proto.milvus.OperatePrivilegeGroupRequest
-	(*milvuspb.CheckHealthRequest)(nil),            // 70: milvus.proto.milvus.CheckHealthRequest
-	(*milvuspb.RenameCollectionRequest)(nil),       // 71: milvus.proto.milvus.RenameCollectionRequest
-	(*milvuspb.CreateDatabaseRequest)(nil),         // 72: milvus.proto.milvus.CreateDatabaseRequest
-	(*milvuspb.DropDatabaseRequest)(nil),           // 73: milvus.proto.milvus.DropDatabaseRequest
-	(*milvuspb.ListDatabasesRequest)(nil),          // 74: milvus.proto.milvus.ListDatabasesRequest
-	(*internalpb.GetQuotaMetricsRequest)(nil),      // 75: milvus.proto.internal.GetQuotaMetricsRequest
-	(*milvuspb.ComponentStates)(nil),               // 76: milvus.proto.milvus.ComponentStates
-	(*milvuspb.StringResponse)(nil),                // 77: milvus.proto.milvus.StringResponse
-	(*milvuspb.BoolResponse)(nil),                  // 78: milvus.proto.milvus.BoolResponse
-	(*milvuspb.DescribeCollectionResponse)(nil),    // 79: milvus.proto.milvus.DescribeCollectionResponse
-	(*milvuspb.DescribeAliasResponse)(nil),         // 80: milvus.proto.milvus.DescribeAliasResponse
-	(*milvuspb.ListAliasesResponse)(nil),           // 81: milvus.proto.milvus.ListAliasesResponse
-	(*milvuspb.ShowCollectionsResponse)(nil),       // 82: milvus.proto.milvus.ShowCollectionsResponse
-	(*milvuspb.ShowPartitionsResponse)(nil),        // 83: milvus.proto.milvus.ShowPartitionsResponse
-	(*milvuspb.ShowSegmentsResponse)(nil),          // 84: milvus.proto.milvus.ShowSegmentsResponse
-	(*internalpb.ShowConfigurationsResponse)(nil),  // 85: milvus.proto.internal.ShowConfigurationsResponse
-	(*milvuspb.GetMetricsResponse)(nil),            // 86: milvus.proto.milvus.GetMetricsResponse
-	(*milvuspb.ListCredUsersResponse)(nil),         // 87: milvus.proto.milvus.ListCredUsersResponse
-	(*milvuspb.SelectRoleResponse)(nil),            // 88: milvus.proto.milvus.SelectRoleResponse
-	(*milvuspb.SelectUserResponse)(nil),            // 89: milvus.proto.milvus.SelectUserResponse
-	(*milvuspb.SelectGrantResponse)(nil),           // 90: milvus.proto.milvus.SelectGrantResponse
-	(*internalpb.ListPolicyResponse)(nil),          // 91: milvus.proto.internal.ListPolicyResponse
-	(*milvuspb.BackupRBACMetaResponse)(nil),        // 92: milvus.proto.milvus.BackupRBACMetaResponse
-	(*milvuspb.ListPrivilegeGroupsResponse)(nil),   // 93: milvus.proto.milvus.ListPrivilegeGroupsResponse
-	(*milvuspb.CheckHealthResponse)(nil),           // 94: milvus.proto.milvus.CheckHealthResponse
-	(*milvuspb.ListDatabasesResponse)(nil),         // 95: milvus.proto.milvus.ListDatabasesResponse
-	(*internalpb.GetQuotaMetricsResponse)(nil),     // 96: milvus.proto.internal.GetQuotaMetricsResponse
+	(*AllocTimestampRequest)(nil),                   // 0: milvus.proto.rootcoord.AllocTimestampRequest
+	(*AllocTimestampResponse)(nil),                  // 1: milvus.proto.rootcoord.AllocTimestampResponse
+	(*AllocIDRequest)(nil),                          // 2: milvus.proto.rootcoord.AllocIDRequest
+	(*AllocIDResponse)(nil),                         // 3: milvus.proto.rootcoord.AllocIDResponse
+	(*DescribeSegmentsRequest)(nil),                 // 4: milvus.proto.rootcoord.DescribeSegmentsRequest
+	(*SegmentBaseInfo)(nil),                         // 5: milvus.proto.rootcoord.SegmentBaseInfo
+	(*SegmentInfos)(nil),                            // 6: milvus.proto.rootcoord.SegmentInfos
+	(*DescribeSegmentsResponse)(nil),                // 7: milvus.proto.rootcoord.DescribeSegmentsResponse
+	(*GetCredentialRequest)(nil),                    // 8: milvus.proto.rootcoord.GetCredentialRequest
+	(*GetCredentialResponse)(nil),                   // 9: milvus.proto.rootcoord.GetCredentialResponse
+	(*DescribeDatabaseRequest)(nil),                 // 10: milvus.proto.rootcoord.DescribeDatabaseRequest
+	(*DescribeDatabaseResponse)(nil),                // 11: milvus.proto.rootcoord.DescribeDatabaseResponse
+	(*AlterDatabaseRequest)(nil),                    // 12: milvus.proto.rootcoord.AlterDatabaseRequest
+	(*GetPChannelInfoRequest)(nil),                  // 13: milvus.proto.rootcoord.GetPChannelInfoRequest
+	(*GetPChannelInfoResponse)(nil),                 // 14: milvus.proto.rootcoord.GetPChannelInfoResponse
+	(*CollectionInfoOnPChannel)(nil),                // 15: milvus.proto.rootcoord.CollectionInfoOnPChannel
+	(*PartitionInfoOnPChannel)(nil),                 // 16: milvus.proto.rootcoord.PartitionInfoOnPChannel
+	(*ShowCollectionIDsRequest)(nil),                // 17: milvus.proto.rootcoord.ShowCollectionIDsRequest
+	(*DBCollections)(nil),                           // 18: milvus.proto.rootcoord.DBCollections
+	(*ShowCollectionIDsResponse)(nil),               // 19: milvus.proto.rootcoord.ShowCollectionIDsResponse
+	nil,                                             // 20: milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry
+	nil,                                             // 21: milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry
+	(*commonpb.MsgBase)(nil),                        // 22: milvus.proto.common.MsgBase
+	(*commonpb.Status)(nil),                         // 23: milvus.proto.common.Status
+	(*etcdpb.SegmentIndexInfo)(nil),                 // 24: milvus.proto.etcd.SegmentIndexInfo
+	(*commonpb.KeyValuePair)(nil),                   // 25: milvus.proto.common.KeyValuePair
+	(etcdpb.CollectionState)(0),                     // 26: milvus.proto.etcd.CollectionState
+	(*etcdpb.IndexInfo)(nil),                        // 27: milvus.proto.etcd.IndexInfo
+	(*milvuspb.GetComponentStatesRequest)(nil),      // 28: milvus.proto.milvus.GetComponentStatesRequest
+	(*internalpb.GetTimeTickChannelRequest)(nil),    // 29: milvus.proto.internal.GetTimeTickChannelRequest
+	(*internalpb.GetStatisticsChannelRequest)(nil),  // 30: milvus.proto.internal.GetStatisticsChannelRequest
+	(*milvuspb.CreateCollectionRequest)(nil),        // 31: milvus.proto.milvus.CreateCollectionRequest
+	(*milvuspb.DropCollectionRequest)(nil),          // 32: milvus.proto.milvus.DropCollectionRequest
+	(*milvuspb.AddCollectionFieldRequest)(nil),      // 33: milvus.proto.milvus.AddCollectionFieldRequest
+	(*milvuspb.HasCollectionRequest)(nil),           // 34: milvus.proto.milvus.HasCollectionRequest
+	(*milvuspb.DescribeCollectionRequest)(nil),      // 35: milvus.proto.milvus.DescribeCollectionRequest
+	(*milvuspb.CreateAliasRequest)(nil),             // 36: milvus.proto.milvus.CreateAliasRequest
+	(*milvuspb.DropAliasRequest)(nil),               // 37: milvus.proto.milvus.DropAliasRequest
+	(*milvuspb.AlterAliasRequest)(nil),              // 38: milvus.proto.milvus.AlterAliasRequest
+	(*milvuspb.DescribeAliasRequest)(nil),           // 39: milvus.proto.milvus.DescribeAliasRequest
+	(*milvuspb.ListAliasesRequest)(nil),             // 40: milvus.proto.milvus.ListAliasesRequest
+	(*milvuspb.ShowCollectionsRequest)(nil),         // 41: milvus.proto.milvus.ShowCollectionsRequest
+	(*milvuspb.AlterCollectionRequest)(nil),         // 42: milvus.proto.milvus.AlterCollectionRequest
+	(*milvuspb.AlterCollectionFieldRequest)(nil),    // 43: milvus.proto.milvus.AlterCollectionFieldRequest
+	(*milvuspb.AddCollectionFunctionRequest)(nil),   // 44: milvus.proto.milvus.AddCollectionFunctionRequest
+	(*milvuspb.AlterCollectionFunctionRequest)(nil), // 45: milvus.proto.milvus.AlterCollectionFunctionRequest
+	(*milvuspb.DropCollectionFunctionRequest)(nil),  // 46: milvus.proto.milvus.DropCollectionFunctionRequest
+	(*milvuspb.CreatePartitionRequest)(nil),         // 47: milvus.proto.milvus.CreatePartitionRequest
+	(*milvuspb.DropPartitionRequest)(nil),           // 48: milvus.proto.milvus.DropPartitionRequest
+	(*milvuspb.HasPartitionRequest)(nil),            // 49: milvus.proto.milvus.HasPartitionRequest
+	(*milvuspb.ShowPartitionsRequest)(nil),          // 50: milvus.proto.milvus.ShowPartitionsRequest
+	(*milvuspb.ShowSegmentsRequest)(nil),            // 51: milvus.proto.milvus.ShowSegmentsRequest
+	(*internalpb.ChannelTimeTickMsg)(nil),           // 52: milvus.proto.internal.ChannelTimeTickMsg
+	(*proxypb.InvalidateCollMetaCacheRequest)(nil),  // 53: milvus.proto.proxy.InvalidateCollMetaCacheRequest
+	(*internalpb.ShowConfigurationsRequest)(nil),    // 54: milvus.proto.internal.ShowConfigurationsRequest
+	(*milvuspb.GetMetricsRequest)(nil),              // 55: milvus.proto.milvus.GetMetricsRequest
+	(*internalpb.CredentialInfo)(nil),               // 56: milvus.proto.internal.CredentialInfo
+	(*milvuspb.DeleteCredentialRequest)(nil),        // 57: milvus.proto.milvus.DeleteCredentialRequest
+	(*milvuspb.ListCredUsersRequest)(nil),           // 58: milvus.proto.milvus.ListCredUsersRequest
+	(*milvuspb.CreateRoleRequest)(nil),              // 59: milvus.proto.milvus.CreateRoleRequest
+	(*milvuspb.DropRoleRequest)(nil),                // 60: milvus.proto.milvus.DropRoleRequest
+	(*milvuspb.OperateUserRoleRequest)(nil),         // 61: milvus.proto.milvus.OperateUserRoleRequest
+	(*milvuspb.SelectRoleRequest)(nil),              // 62: milvus.proto.milvus.SelectRoleRequest
+	(*milvuspb.SelectUserRequest)(nil),              // 63: milvus.proto.milvus.SelectUserRequest
+	(*milvuspb.OperatePrivilegeRequest)(nil),        // 64: milvus.proto.milvus.OperatePrivilegeRequest
+	(*milvuspb.SelectGrantRequest)(nil),             // 65: milvus.proto.milvus.SelectGrantRequest
+	(*internalpb.ListPolicyRequest)(nil),            // 66: milvus.proto.internal.ListPolicyRequest
+	(*milvuspb.BackupRBACMetaRequest)(nil),          // 67: milvus.proto.milvus.BackupRBACMetaRequest
+	(*milvuspb.RestoreRBACMetaRequest)(nil),         // 68: milvus.proto.milvus.RestoreRBACMetaRequest
+	(*milvuspb.CreatePrivilegeGroupRequest)(nil),    // 69: milvus.proto.milvus.CreatePrivilegeGroupRequest
+	(*milvuspb.DropPrivilegeGroupRequest)(nil),      // 70: milvus.proto.milvus.DropPrivilegeGroupRequest
+	(*milvuspb.ListPrivilegeGroupsRequest)(nil),     // 71: milvus.proto.milvus.ListPrivilegeGroupsRequest
+	(*milvuspb.OperatePrivilegeGroupRequest)(nil),   // 72: milvus.proto.milvus.OperatePrivilegeGroupRequest
+	(*milvuspb.CheckHealthRequest)(nil),             // 73: milvus.proto.milvus.CheckHealthRequest
+	(*milvuspb.RenameCollectionRequest)(nil),        // 74: milvus.proto.milvus.RenameCollectionRequest
+	(*milvuspb.CreateDatabaseRequest)(nil),          // 75: milvus.proto.milvus.CreateDatabaseRequest
+	(*milvuspb.DropDatabaseRequest)(nil),            // 76: milvus.proto.milvus.DropDatabaseRequest
+	(*milvuspb.ListDatabasesRequest)(nil),           // 77: milvus.proto.milvus.ListDatabasesRequest
+	(*internalpb.GetQuotaMetricsRequest)(nil),       // 78: milvus.proto.internal.GetQuotaMetricsRequest
+	(*milvuspb.ComponentStates)(nil),                // 79: milvus.proto.milvus.ComponentStates
+	(*milvuspb.StringResponse)(nil),                 // 80: milvus.proto.milvus.StringResponse
+	(*milvuspb.BoolResponse)(nil),                   // 81: milvus.proto.milvus.BoolResponse
+	(*milvuspb.DescribeCollectionResponse)(nil),     // 82: milvus.proto.milvus.DescribeCollectionResponse
+	(*milvuspb.DescribeAliasResponse)(nil),          // 83: milvus.proto.milvus.DescribeAliasResponse
+	(*milvuspb.ListAliasesResponse)(nil),            // 84: milvus.proto.milvus.ListAliasesResponse
+	(*milvuspb.ShowCollectionsResponse)(nil),        // 85: milvus.proto.milvus.ShowCollectionsResponse
+	(*milvuspb.ShowPartitionsResponse)(nil),         // 86: milvus.proto.milvus.ShowPartitionsResponse
+	(*milvuspb.ShowSegmentsResponse)(nil),           // 87: milvus.proto.milvus.ShowSegmentsResponse
+	(*internalpb.ShowConfigurationsResponse)(nil),   // 88: milvus.proto.internal.ShowConfigurationsResponse
+	(*milvuspb.GetMetricsResponse)(nil),             // 89: milvus.proto.milvus.GetMetricsResponse
+	(*milvuspb.ListCredUsersResponse)(nil),          // 90: milvus.proto.milvus.ListCredUsersResponse
+	(*milvuspb.SelectRoleResponse)(nil),             // 91: milvus.proto.milvus.SelectRoleResponse
+	(*milvuspb.SelectUserResponse)(nil),             // 92: milvus.proto.milvus.SelectUserResponse
+	(*milvuspb.SelectGrantResponse)(nil),            // 93: milvus.proto.milvus.SelectGrantResponse
+	(*internalpb.ListPolicyResponse)(nil),           // 94: milvus.proto.internal.ListPolicyResponse
+	(*milvuspb.BackupRBACMetaResponse)(nil),         // 95: milvus.proto.milvus.BackupRBACMetaResponse
+	(*milvuspb.ListPrivilegeGroupsResponse)(nil),    // 96: milvus.proto.milvus.ListPrivilegeGroupsResponse
+	(*milvuspb.CheckHealthResponse)(nil),            // 97: milvus.proto.milvus.CheckHealthResponse
+	(*milvuspb.ListDatabasesResponse)(nil),          // 98: milvus.proto.milvus.ListDatabasesResponse
+	(*internalpb.GetQuotaMetricsResponse)(nil),      // 99: milvus.proto.internal.GetQuotaMetricsResponse
 }
 var file_root_coord_proto_depIdxs = []int32{
 	22, // 0: milvus.proto.rootcoord.AllocTimestampRequest.base:type_name -> milvus.proto.common.MsgBase
@@ -2003,106 +2027,112 @@ var file_root_coord_proto_depIdxs = []int32{
 	17, // 42: milvus.proto.rootcoord.RootCoord.ShowCollectionIDs:input_type -> milvus.proto.rootcoord.ShowCollectionIDsRequest
 	42, // 43: milvus.proto.rootcoord.RootCoord.AlterCollection:input_type -> milvus.proto.milvus.AlterCollectionRequest
 	43, // 44: milvus.proto.rootcoord.RootCoord.AlterCollectionField:input_type -> milvus.proto.milvus.AlterCollectionFieldRequest
-	44, // 45: milvus.proto.rootcoord.RootCoord.CreatePartition:input_type -> milvus.proto.milvus.CreatePartitionRequest
-	45, // 46: milvus.proto.rootcoord.RootCoord.DropPartition:input_type -> milvus.proto.milvus.DropPartitionRequest
-	46, // 47: milvus.proto.rootcoord.RootCoord.HasPartition:input_type -> milvus.proto.milvus.HasPartitionRequest
-	47, // 48: milvus.proto.rootcoord.RootCoord.ShowPartitions:input_type -> milvus.proto.milvus.ShowPartitionsRequest
-	47, // 49: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:input_type -> milvus.proto.milvus.ShowPartitionsRequest
-	48, // 50: milvus.proto.rootcoord.RootCoord.ShowSegments:input_type -> milvus.proto.milvus.ShowSegmentsRequest
-	13, // 51: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:input_type -> milvus.proto.rootcoord.GetPChannelInfoRequest
-	0,  // 52: milvus.proto.rootcoord.RootCoord.AllocTimestamp:input_type -> milvus.proto.rootcoord.AllocTimestampRequest
-	2,  // 53: milvus.proto.rootcoord.RootCoord.AllocID:input_type -> milvus.proto.rootcoord.AllocIDRequest
-	49, // 54: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:input_type -> milvus.proto.internal.ChannelTimeTickMsg
-	50, // 55: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:input_type -> milvus.proto.proxy.InvalidateCollMetaCacheRequest
-	51, // 56: milvus.proto.rootcoord.RootCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest
-	52, // 57: milvus.proto.rootcoord.RootCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest
-	53, // 58: milvus.proto.rootcoord.RootCoord.CreateCredential:input_type -> milvus.proto.internal.CredentialInfo
-	53, // 59: milvus.proto.rootcoord.RootCoord.UpdateCredential:input_type -> milvus.proto.internal.CredentialInfo
-	54, // 60: milvus.proto.rootcoord.RootCoord.DeleteCredential:input_type -> milvus.proto.milvus.DeleteCredentialRequest
-	55, // 61: milvus.proto.rootcoord.RootCoord.ListCredUsers:input_type -> milvus.proto.milvus.ListCredUsersRequest
-	8,  // 62: milvus.proto.rootcoord.RootCoord.GetCredential:input_type -> milvus.proto.rootcoord.GetCredentialRequest
-	56, // 63: milvus.proto.rootcoord.RootCoord.CreateRole:input_type -> milvus.proto.milvus.CreateRoleRequest
-	57, // 64: milvus.proto.rootcoord.RootCoord.DropRole:input_type -> milvus.proto.milvus.DropRoleRequest
-	58, // 65: milvus.proto.rootcoord.RootCoord.OperateUserRole:input_type -> milvus.proto.milvus.OperateUserRoleRequest
-	59, // 66: milvus.proto.rootcoord.RootCoord.SelectRole:input_type -> milvus.proto.milvus.SelectRoleRequest
-	60, // 67: milvus.proto.rootcoord.RootCoord.SelectUser:input_type -> milvus.proto.milvus.SelectUserRequest
-	61, // 68: milvus.proto.rootcoord.RootCoord.OperatePrivilege:input_type -> milvus.proto.milvus.OperatePrivilegeRequest
-	62, // 69: milvus.proto.rootcoord.RootCoord.SelectGrant:input_type -> milvus.proto.milvus.SelectGrantRequest
-	63, // 70: milvus.proto.rootcoord.RootCoord.ListPolicy:input_type -> milvus.proto.internal.ListPolicyRequest
-	64, // 71: milvus.proto.rootcoord.RootCoord.BackupRBAC:input_type -> milvus.proto.milvus.BackupRBACMetaRequest
-	65, // 72: milvus.proto.rootcoord.RootCoord.RestoreRBAC:input_type -> milvus.proto.milvus.RestoreRBACMetaRequest
-	66, // 73: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:input_type -> milvus.proto.milvus.CreatePrivilegeGroupRequest
-	67, // 74: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:input_type -> milvus.proto.milvus.DropPrivilegeGroupRequest
-	68, // 75: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:input_type -> milvus.proto.milvus.ListPrivilegeGroupsRequest
-	69, // 76: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:input_type -> milvus.proto.milvus.OperatePrivilegeGroupRequest
-	70, // 77: milvus.proto.rootcoord.RootCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest
-	71, // 78: milvus.proto.rootcoord.RootCoord.RenameCollection:input_type -> milvus.proto.milvus.RenameCollectionRequest
-	72, // 79: milvus.proto.rootcoord.RootCoord.CreateDatabase:input_type -> milvus.proto.milvus.CreateDatabaseRequest
-	73, // 80: milvus.proto.rootcoord.RootCoord.DropDatabase:input_type -> milvus.proto.milvus.DropDatabaseRequest
-	74, // 81: milvus.proto.rootcoord.RootCoord.ListDatabases:input_type -> milvus.proto.milvus.ListDatabasesRequest
-	10, // 82: milvus.proto.rootcoord.RootCoord.DescribeDatabase:input_type -> milvus.proto.rootcoord.DescribeDatabaseRequest
-	12, // 83: milvus.proto.rootcoord.RootCoord.AlterDatabase:input_type -> milvus.proto.rootcoord.AlterDatabaseRequest
-	75, // 84: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:input_type -> milvus.proto.internal.GetQuotaMetricsRequest
-	76, // 85: milvus.proto.rootcoord.RootCoord.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates
-	77, // 86: milvus.proto.rootcoord.RootCoord.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse
-	77, // 87: milvus.proto.rootcoord.RootCoord.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse
-	23, // 88: milvus.proto.rootcoord.RootCoord.CreateCollection:output_type -> milvus.proto.common.Status
-	23, // 89: milvus.proto.rootcoord.RootCoord.DropCollection:output_type -> milvus.proto.common.Status
-	23, // 90: milvus.proto.rootcoord.RootCoord.AddCollectionField:output_type -> milvus.proto.common.Status
-	78, // 91: milvus.proto.rootcoord.RootCoord.HasCollection:output_type -> milvus.proto.milvus.BoolResponse
-	79, // 92: milvus.proto.rootcoord.RootCoord.DescribeCollection:output_type -> milvus.proto.milvus.DescribeCollectionResponse
-	79, // 93: milvus.proto.rootcoord.RootCoord.DescribeCollectionInternal:output_type -> milvus.proto.milvus.DescribeCollectionResponse
-	23, // 94: milvus.proto.rootcoord.RootCoord.CreateAlias:output_type -> milvus.proto.common.Status
-	23, // 95: milvus.proto.rootcoord.RootCoord.DropAlias:output_type -> milvus.proto.common.Status
-	23, // 96: milvus.proto.rootcoord.RootCoord.AlterAlias:output_type -> milvus.proto.common.Status
-	80, // 97: milvus.proto.rootcoord.RootCoord.DescribeAlias:output_type -> milvus.proto.milvus.DescribeAliasResponse
-	81, // 98: milvus.proto.rootcoord.RootCoord.ListAliases:output_type -> milvus.proto.milvus.ListAliasesResponse
-	82, // 99: milvus.proto.rootcoord.RootCoord.ShowCollections:output_type -> milvus.proto.milvus.ShowCollectionsResponse
-	19, // 100: milvus.proto.rootcoord.RootCoord.ShowCollectionIDs:output_type -> milvus.proto.rootcoord.ShowCollectionIDsResponse
-	23, // 101: milvus.proto.rootcoord.RootCoord.AlterCollection:output_type -> milvus.proto.common.Status
-	23, // 102: milvus.proto.rootcoord.RootCoord.AlterCollectionField:output_type -> milvus.proto.common.Status
-	23, // 103: milvus.proto.rootcoord.RootCoord.CreatePartition:output_type -> milvus.proto.common.Status
-	23, // 104: milvus.proto.rootcoord.RootCoord.DropPartition:output_type -> milvus.proto.common.Status
-	78, // 105: milvus.proto.rootcoord.RootCoord.HasPartition:output_type -> milvus.proto.milvus.BoolResponse
-	83, // 106: milvus.proto.rootcoord.RootCoord.ShowPartitions:output_type -> milvus.proto.milvus.ShowPartitionsResponse
-	83, // 107: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:output_type -> milvus.proto.milvus.ShowPartitionsResponse
-	84, // 108: milvus.proto.rootcoord.RootCoord.ShowSegments:output_type -> milvus.proto.milvus.ShowSegmentsResponse
-	14, // 109: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:output_type -> milvus.proto.rootcoord.GetPChannelInfoResponse
-	1,  // 110: milvus.proto.rootcoord.RootCoord.AllocTimestamp:output_type -> milvus.proto.rootcoord.AllocTimestampResponse
-	3,  // 111: milvus.proto.rootcoord.RootCoord.AllocID:output_type -> milvus.proto.rootcoord.AllocIDResponse
-	23, // 112: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:output_type -> milvus.proto.common.Status
-	23, // 113: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:output_type -> milvus.proto.common.Status
-	85, // 114: milvus.proto.rootcoord.RootCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse
-	86, // 115: milvus.proto.rootcoord.RootCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse
-	23, // 116: milvus.proto.rootcoord.RootCoord.CreateCredential:output_type -> milvus.proto.common.Status
-	23, // 117: milvus.proto.rootcoord.RootCoord.UpdateCredential:output_type -> milvus.proto.common.Status
-	23, // 118: milvus.proto.rootcoord.RootCoord.DeleteCredential:output_type -> milvus.proto.common.Status
-	87, // 119: milvus.proto.rootcoord.RootCoord.ListCredUsers:output_type -> milvus.proto.milvus.ListCredUsersResponse
-	9,  // 120: milvus.proto.rootcoord.RootCoord.GetCredential:output_type -> milvus.proto.rootcoord.GetCredentialResponse
-	23, // 121: milvus.proto.rootcoord.RootCoord.CreateRole:output_type -> milvus.proto.common.Status
-	23, // 122: milvus.proto.rootcoord.RootCoord.DropRole:output_type -> milvus.proto.common.Status
-	23, // 123: milvus.proto.rootcoord.RootCoord.OperateUserRole:output_type -> milvus.proto.common.Status
-	88, // 124: milvus.proto.rootcoord.RootCoord.SelectRole:output_type -> milvus.proto.milvus.SelectRoleResponse
-	89, // 125: milvus.proto.rootcoord.RootCoord.SelectUser:output_type -> milvus.proto.milvus.SelectUserResponse
-	23, // 126: milvus.proto.rootcoord.RootCoord.OperatePrivilege:output_type -> milvus.proto.common.Status
-	90, // 127: milvus.proto.rootcoord.RootCoord.SelectGrant:output_type -> milvus.proto.milvus.SelectGrantResponse
-	91, // 128: milvus.proto.rootcoord.RootCoord.ListPolicy:output_type -> milvus.proto.internal.ListPolicyResponse
-	92, // 129: milvus.proto.rootcoord.RootCoord.BackupRBAC:output_type -> milvus.proto.milvus.BackupRBACMetaResponse
-	23, // 130: milvus.proto.rootcoord.RootCoord.RestoreRBAC:output_type -> milvus.proto.common.Status
-	23, // 131: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:output_type -> milvus.proto.common.Status
-	23, // 132: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:output_type -> milvus.proto.common.Status
-	93, // 133: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:output_type -> milvus.proto.milvus.ListPrivilegeGroupsResponse
-	23, // 134: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:output_type -> milvus.proto.common.Status
-	94, // 135: milvus.proto.rootcoord.RootCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse
-	23, // 136: milvus.proto.rootcoord.RootCoord.RenameCollection:output_type -> milvus.proto.common.Status
-	23, // 137: milvus.proto.rootcoord.RootCoord.CreateDatabase:output_type -> milvus.proto.common.Status
-	23, // 138: milvus.proto.rootcoord.RootCoord.DropDatabase:output_type -> milvus.proto.common.Status
-	95, // 139: milvus.proto.rootcoord.RootCoord.ListDatabases:output_type -> milvus.proto.milvus.ListDatabasesResponse
-	11, // 140: milvus.proto.rootcoord.RootCoord.DescribeDatabase:output_type -> milvus.proto.rootcoord.DescribeDatabaseResponse
-	23, // 141: milvus.proto.rootcoord.RootCoord.AlterDatabase:output_type -> milvus.proto.common.Status
-	96, // 142: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:output_type -> milvus.proto.internal.GetQuotaMetricsResponse
-	85, // [85:143] is the sub-list for method output_type
-	27, // [27:85] is the sub-list for method input_type
+	44, // 45: milvus.proto.rootcoord.RootCoord.AddCollectionFunction:input_type -> milvus.proto.milvus.AddCollectionFunctionRequest
+	45, // 46: milvus.proto.rootcoord.RootCoord.AlterCollectionFunction:input_type -> milvus.proto.milvus.AlterCollectionFunctionRequest
+	46, // 47: milvus.proto.rootcoord.RootCoord.DropCollectionFunction:input_type -> milvus.proto.milvus.DropCollectionFunctionRequest
+	47, // 48: milvus.proto.rootcoord.RootCoord.CreatePartition:input_type -> milvus.proto.milvus.CreatePartitionRequest
+	48, // 49: milvus.proto.rootcoord.RootCoord.DropPartition:input_type -> milvus.proto.milvus.DropPartitionRequest
+	49, // 50: milvus.proto.rootcoord.RootCoord.HasPartition:input_type -> milvus.proto.milvus.HasPartitionRequest
+	50, // 51: milvus.proto.rootcoord.RootCoord.ShowPartitions:input_type -> milvus.proto.milvus.ShowPartitionsRequest
+	50, // 52: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:input_type -> milvus.proto.milvus.ShowPartitionsRequest
+	51, // 53: milvus.proto.rootcoord.RootCoord.ShowSegments:input_type -> milvus.proto.milvus.ShowSegmentsRequest
+	13, // 54: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:input_type -> milvus.proto.rootcoord.GetPChannelInfoRequest
+	0,  // 55: milvus.proto.rootcoord.RootCoord.AllocTimestamp:input_type -> milvus.proto.rootcoord.AllocTimestampRequest
+	2,  // 56: milvus.proto.rootcoord.RootCoord.AllocID:input_type -> milvus.proto.rootcoord.AllocIDRequest
+	52, // 57: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:input_type -> milvus.proto.internal.ChannelTimeTickMsg
+	53, // 58: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:input_type -> milvus.proto.proxy.InvalidateCollMetaCacheRequest
+	54, // 59: milvus.proto.rootcoord.RootCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest
+	55, // 60: milvus.proto.rootcoord.RootCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest
+	56, // 61: milvus.proto.rootcoord.RootCoord.CreateCredential:input_type -> milvus.proto.internal.CredentialInfo
+	56, // 62: milvus.proto.rootcoord.RootCoord.UpdateCredential:input_type -> milvus.proto.internal.CredentialInfo
+	57, // 63: milvus.proto.rootcoord.RootCoord.DeleteCredential:input_type -> milvus.proto.milvus.DeleteCredentialRequest
+	58, // 64: milvus.proto.rootcoord.RootCoord.ListCredUsers:input_type -> milvus.proto.milvus.ListCredUsersRequest
+	8,  // 65: milvus.proto.rootcoord.RootCoord.GetCredential:input_type -> milvus.proto.rootcoord.GetCredentialRequest
+	59, // 66: milvus.proto.rootcoord.RootCoord.CreateRole:input_type -> milvus.proto.milvus.CreateRoleRequest
+	60, // 67: milvus.proto.rootcoord.RootCoord.DropRole:input_type -> milvus.proto.milvus.DropRoleRequest
+	61, // 68: milvus.proto.rootcoord.RootCoord.OperateUserRole:input_type -> milvus.proto.milvus.OperateUserRoleRequest
+	62, // 69: milvus.proto.rootcoord.RootCoord.SelectRole:input_type -> milvus.proto.milvus.SelectRoleRequest
+	63, // 70: milvus.proto.rootcoord.RootCoord.SelectUser:input_type -> milvus.proto.milvus.SelectUserRequest
+	64, // 71: milvus.proto.rootcoord.RootCoord.OperatePrivilege:input_type -> milvus.proto.milvus.OperatePrivilegeRequest
+	65, // 72: milvus.proto.rootcoord.RootCoord.SelectGrant:input_type -> milvus.proto.milvus.SelectGrantRequest
+	66, // 73: milvus.proto.rootcoord.RootCoord.ListPolicy:input_type -> milvus.proto.internal.ListPolicyRequest
+	67, // 74: milvus.proto.rootcoord.RootCoord.BackupRBAC:input_type -> milvus.proto.milvus.BackupRBACMetaRequest
+	68, // 75: milvus.proto.rootcoord.RootCoord.RestoreRBAC:input_type -> milvus.proto.milvus.RestoreRBACMetaRequest
+	69, // 76: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:input_type -> milvus.proto.milvus.CreatePrivilegeGroupRequest
+	70, // 77: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:input_type -> milvus.proto.milvus.DropPrivilegeGroupRequest
+	71, // 78: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:input_type -> milvus.proto.milvus.ListPrivilegeGroupsRequest
+	72, // 79: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:input_type -> milvus.proto.milvus.OperatePrivilegeGroupRequest
+	73, // 80: milvus.proto.rootcoord.RootCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest
+	74, // 81: milvus.proto.rootcoord.RootCoord.RenameCollection:input_type -> milvus.proto.milvus.RenameCollectionRequest
+	75, // 82: milvus.proto.rootcoord.RootCoord.CreateDatabase:input_type -> milvus.proto.milvus.CreateDatabaseRequest
+	76, // 83: milvus.proto.rootcoord.RootCoord.DropDatabase:input_type -> milvus.proto.milvus.DropDatabaseRequest
+	77, // 84: milvus.proto.rootcoord.RootCoord.ListDatabases:input_type -> milvus.proto.milvus.ListDatabasesRequest
+	10, // 85: milvus.proto.rootcoord.RootCoord.DescribeDatabase:input_type -> milvus.proto.rootcoord.DescribeDatabaseRequest
+	12, // 86: milvus.proto.rootcoord.RootCoord.AlterDatabase:input_type -> milvus.proto.rootcoord.AlterDatabaseRequest
+	78, // 87: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:input_type -> milvus.proto.internal.GetQuotaMetricsRequest
+	79, // 88: milvus.proto.rootcoord.RootCoord.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates
+	80, // 89: milvus.proto.rootcoord.RootCoord.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse
+	80, // 90: milvus.proto.rootcoord.RootCoord.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse
+	23, // 91: milvus.proto.rootcoord.RootCoord.CreateCollection:output_type -> milvus.proto.common.Status
+	23, // 92: milvus.proto.rootcoord.RootCoord.DropCollection:output_type -> milvus.proto.common.Status
+	23, // 93: milvus.proto.rootcoord.RootCoord.AddCollectionField:output_type -> milvus.proto.common.Status
+	81, // 94: milvus.proto.rootcoord.RootCoord.HasCollection:output_type -> milvus.proto.milvus.BoolResponse
+	82, // 95: milvus.proto.rootcoord.RootCoord.DescribeCollection:output_type -> milvus.proto.milvus.DescribeCollectionResponse
+	82, // 96: milvus.proto.rootcoord.RootCoord.DescribeCollectionInternal:output_type -> milvus.proto.milvus.DescribeCollectionResponse
+	23, // 97: milvus.proto.rootcoord.RootCoord.CreateAlias:output_type -> milvus.proto.common.Status
+	23, // 98: milvus.proto.rootcoord.RootCoord.DropAlias:output_type -> milvus.proto.common.Status
+	23, // 99: milvus.proto.rootcoord.RootCoord.AlterAlias:output_type -> milvus.proto.common.Status
+	83, // 100: milvus.proto.rootcoord.RootCoord.DescribeAlias:output_type -> milvus.proto.milvus.DescribeAliasResponse
+	84, // 101: milvus.proto.rootcoord.RootCoord.ListAliases:output_type -> milvus.proto.milvus.ListAliasesResponse
+	85, // 102: milvus.proto.rootcoord.RootCoord.ShowCollections:output_type -> milvus.proto.milvus.ShowCollectionsResponse
+	19, // 103: milvus.proto.rootcoord.RootCoord.ShowCollectionIDs:output_type -> milvus.proto.rootcoord.ShowCollectionIDsResponse
+	23, // 104: milvus.proto.rootcoord.RootCoord.AlterCollection:output_type -> milvus.proto.common.Status
+	23, // 105: milvus.proto.rootcoord.RootCoord.AlterCollectionField:output_type -> milvus.proto.common.Status
+	23, // 106: milvus.proto.rootcoord.RootCoord.AddCollectionFunction:output_type -> milvus.proto.common.Status
+	23, // 107: milvus.proto.rootcoord.RootCoord.AlterCollectionFunction:output_type -> milvus.proto.common.Status
+	23, // 108: milvus.proto.rootcoord.RootCoord.DropCollectionFunction:output_type -> milvus.proto.common.Status
+	23, // 109: milvus.proto.rootcoord.RootCoord.CreatePartition:output_type -> milvus.proto.common.Status
+	23, // 110: milvus.proto.rootcoord.RootCoord.DropPartition:output_type -> milvus.proto.common.Status
+	81, // 111: milvus.proto.rootcoord.RootCoord.HasPartition:output_type -> milvus.proto.milvus.BoolResponse
+	86, // 112: milvus.proto.rootcoord.RootCoord.ShowPartitions:output_type -> milvus.proto.milvus.ShowPartitionsResponse
+	86, // 113: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:output_type -> milvus.proto.milvus.ShowPartitionsResponse
+	87, // 114: milvus.proto.rootcoord.RootCoord.ShowSegments:output_type -> milvus.proto.milvus.ShowSegmentsResponse
+	14, // 115: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:output_type -> milvus.proto.rootcoord.GetPChannelInfoResponse
+	1,  // 116: milvus.proto.rootcoord.RootCoord.AllocTimestamp:output_type -> milvus.proto.rootcoord.AllocTimestampResponse
+	3,  // 117: milvus.proto.rootcoord.RootCoord.AllocID:output_type -> milvus.proto.rootcoord.AllocIDResponse
+	23, // 118: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:output_type -> milvus.proto.common.Status
+	23, // 119: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:output_type -> milvus.proto.common.Status
+	88, // 120: milvus.proto.rootcoord.RootCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse
+	89, // 121: milvus.proto.rootcoord.RootCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse
+	23, // 122: milvus.proto.rootcoord.RootCoord.CreateCredential:output_type -> milvus.proto.common.Status
+	23, // 123: milvus.proto.rootcoord.RootCoord.UpdateCredential:output_type -> milvus.proto.common.Status
+	23, // 124: milvus.proto.rootcoord.RootCoord.DeleteCredential:output_type -> milvus.proto.common.Status
+	90, // 125: milvus.proto.rootcoord.RootCoord.ListCredUsers:output_type -> milvus.proto.milvus.ListCredUsersResponse
+	9,  // 126: milvus.proto.rootcoord.RootCoord.GetCredential:output_type -> milvus.proto.rootcoord.GetCredentialResponse
+	23, // 127: milvus.proto.rootcoord.RootCoord.CreateRole:output_type -> milvus.proto.common.Status
+	23, // 128: milvus.proto.rootcoord.RootCoord.DropRole:output_type -> milvus.proto.common.Status
+	23, // 129: milvus.proto.rootcoord.RootCoord.OperateUserRole:output_type -> milvus.proto.common.Status
+	91, // 130: milvus.proto.rootcoord.RootCoord.SelectRole:output_type -> milvus.proto.milvus.SelectRoleResponse
+	92, // 131: milvus.proto.rootcoord.RootCoord.SelectUser:output_type -> milvus.proto.milvus.SelectUserResponse
+	23, // 132: milvus.proto.rootcoord.RootCoord.OperatePrivilege:output_type -> milvus.proto.common.Status
+	93, // 133: milvus.proto.rootcoord.RootCoord.SelectGrant:output_type -> milvus.proto.milvus.SelectGrantResponse
+	94, // 134: milvus.proto.rootcoord.RootCoord.ListPolicy:output_type -> milvus.proto.internal.ListPolicyResponse
+	95, // 135: milvus.proto.rootcoord.RootCoord.BackupRBAC:output_type -> milvus.proto.milvus.BackupRBACMetaResponse
+	23, // 136: milvus.proto.rootcoord.RootCoord.RestoreRBAC:output_type -> milvus.proto.common.Status
+	23, // 137: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:output_type -> milvus.proto.common.Status
+	23, // 138: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:output_type -> milvus.proto.common.Status
+	96, // 139: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:output_type -> milvus.proto.milvus.ListPrivilegeGroupsResponse
+	23, // 140: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:output_type -> milvus.proto.common.Status
+	97, // 141: milvus.proto.rootcoord.RootCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse
+	23, // 142: milvus.proto.rootcoord.RootCoord.RenameCollection:output_type -> milvus.proto.common.Status
+	23, // 143: milvus.proto.rootcoord.RootCoord.CreateDatabase:output_type -> milvus.proto.common.Status
+	23, // 144: milvus.proto.rootcoord.RootCoord.DropDatabase:output_type -> milvus.proto.common.Status
+	98, // 145: milvus.proto.rootcoord.RootCoord.ListDatabases:output_type -> milvus.proto.milvus.ListDatabasesResponse
+	11, // 146: milvus.proto.rootcoord.RootCoord.DescribeDatabase:output_type -> milvus.proto.rootcoord.DescribeDatabaseResponse
+	23, // 147: milvus.proto.rootcoord.RootCoord.AlterDatabase:output_type -> milvus.proto.common.Status
+	99, // 148: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:output_type -> milvus.proto.internal.GetQuotaMetricsResponse
+	88, // [88:149] is the sub-list for method output_type
+	27, // [27:88] is the sub-list for method input_type
 	27, // [27:27] is the sub-list for extension type_name
 	27, // [27:27] is the sub-list for extension extendee
 	0,  // [0:27] is the sub-list for field type_name

pkg/proto/rootcoordpb/root_coord_grpc.pb.go

@@ -41,6 +41,9 @@ const (
 	RootCoord_ShowCollectionIDs_FullMethodName             = "/milvus.proto.rootcoord.RootCoord/ShowCollectionIDs"
 	RootCoord_AlterCollection_FullMethodName               = "/milvus.proto.rootcoord.RootCoord/AlterCollection"
 	RootCoord_AlterCollectionField_FullMethodName          = "/milvus.proto.rootcoord.RootCoord/AlterCollectionField"
+	RootCoord_AddCollectionFunction_FullMethodName         = "/milvus.proto.rootcoord.RootCoord/AddCollectionFunction"
+	RootCoord_AlterCollectionFunction_FullMethodName       = "/milvus.proto.rootcoord.RootCoord/AlterCollectionFunction"
+	RootCoord_DropCollectionFunction_FullMethodName        = "/milvus.proto.rootcoord.RootCoord/DropCollectionFunction"
 	RootCoord_CreatePartition_FullMethodName               = "/milvus.proto.rootcoord.RootCoord/CreatePartition"
 	RootCoord_DropPartition_FullMethodName                 = "/milvus.proto.rootcoord.RootCoord/DropPartition"
 	RootCoord_HasPartition_FullMethodName                  = "/milvus.proto.rootcoord.RootCoord/HasPartition"
@@ -139,6 +142,9 @@ type RootCoordClient interface {
 	ShowCollectionIDs(ctx context.Context, in *ShowCollectionIDsRequest, opts ...grpc.CallOption) (*ShowCollectionIDsResponse, error)
 	AlterCollection(ctx context.Context, in *milvuspb.AlterCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	AlterCollectionField(ctx context.Context, in *milvuspb.AlterCollectionFieldRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	// *
 	// @brief This method is used to create partition
 	//
@@ -373,6 +379,33 @@ func (c *rootCoordClient) AlterCollectionField(ctx context.Context, in *milvuspb
 	return out, nil
 }
 
+func (c *rootCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, RootCoord_AddCollectionFunction_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *rootCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, RootCoord_AlterCollectionFunction_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *rootCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, RootCoord_DropCollectionFunction_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *rootCoordClient) CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	out := new(commonpb.Status)
 	err := c.cc.Invoke(ctx, RootCoord_CreatePartition_FullMethodName, in, out, opts...)
@@ -789,6 +822,9 @@ type RootCoordServer interface {
 	ShowCollectionIDs(context.Context, *ShowCollectionIDsRequest) (*ShowCollectionIDsResponse, error)
 	AlterCollection(context.Context, *milvuspb.AlterCollectionRequest) (*commonpb.Status, error)
 	AlterCollectionField(context.Context, *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error)
+	AddCollectionFunction(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)
+	AlterCollectionFunction(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)
+	DropCollectionFunction(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)
 	// *
 	// @brief This method is used to create partition
 	//
@@ -911,6 +947,15 @@ func (UnimplementedRootCoordServer) AlterCollection(context.Context, *milvuspb.A
 func (UnimplementedRootCoordServer) AlterCollectionField(context.Context, *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AlterCollectionField not implemented")
 }
+func (UnimplementedRootCoordServer) AddCollectionFunction(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AddCollectionFunction not implemented")
+}
+func (UnimplementedRootCoordServer) AlterCollectionFunction(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AlterCollectionFunction not implemented")
+}
+func (UnimplementedRootCoordServer) DropCollectionFunction(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DropCollectionFunction not implemented")
+}
 func (UnimplementedRootCoordServer) CreatePartition(context.Context, *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method CreatePartition not implemented")
 }
@@ -1367,6 +1412,60 @@ func _RootCoord_AlterCollectionField_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RootCoord_AddCollectionFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.AddCollectionFunctionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RootCoordServer).AddCollectionFunction(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: RootCoord_AddCollectionFunction_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RootCoordServer).AddCollectionFunction(ctx, req.(*milvuspb.AddCollectionFunctionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _RootCoord_AlterCollectionFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.AlterCollectionFunctionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RootCoordServer).AlterCollectionFunction(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: RootCoord_AlterCollectionFunction_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RootCoordServer).AlterCollectionFunction(ctx, req.(*milvuspb.AlterCollectionFunctionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _RootCoord_DropCollectionFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.DropCollectionFunctionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RootCoordServer).DropCollectionFunction(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: RootCoord_DropCollectionFunction_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RootCoordServer).DropCollectionFunction(ctx, req.(*milvuspb.DropCollectionFunctionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _RootCoord_CreatePartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(milvuspb.CreatePartitionRequest)
 	if err := dec(in); err != nil {
@@ -2166,6 +2265,18 @@ var RootCoord_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "AlterCollectionField",
 			Handler:    _RootCoord_AlterCollectionField_Handler,
 		},
+		{
+			MethodName: "AddCollectionFunction",
+			Handler:    _RootCoord_AddCollectionFunction_Handler,
+		},
+		{
+			MethodName: "AlterCollectionFunction",
+			Handler:    _RootCoord_AlterCollectionFunction_Handler,
+		},
+		{
+			MethodName: "DropCollectionFunction",
+			Handler:    _RootCoord_DropCollectionFunction_Handler,
+		},
 		{
 			MethodName: "CreatePartition",
 			Handler:    _RootCoord_CreatePartition_Handler,

pkg/streaming/util/message/codegen/reflect_info.json

@@ -436,4 +436,4 @@
             }
         }
     ]
-}
+}