Add AddCollectionFuntion/AlterCollectionFunction/DropCollectionFunction (milvus-io#471)

Signed-off-by: yhmo <yihua.mo@zilliz.com>

Author: yhmo

.github/mergify.yml

@@ -58,10 +58,16 @@ pull_request_rules:
         add:
           - ci-passed
 
-  - name: Remove ci-passed when build failed
+  - name: Remove ci-passed when checks are not green
     conditions:
       - or: *BRANCHES
       - or:
+          - "check-pending=Detect path changes"
+          - "check-pending=Build and test AMD64 Ubuntu 20.04"
+          - "check-pending=Build and test AMD64 Fedora 39"
+          - "check-pending=Integration test"
+          - "check-pending=Build and test macOS 15"
+          - "check-pending=Build and test windows"
           - "check-failure=Detect path changes"
           - "check-failure=Build and test AMD64 Ubuntu 20.04"
           - "check-failure=Build and test AMD64 Fedora 39"

src/impl/MilvusClientV2Impl.cpp

@@ -547,6 +547,64 @@ MilvusClientV2Impl::AddCollectionField(const AddCollectionFieldRequest& request)
         pre, &MilvusConnection::AddCollectionField);
 }
 
+Status
+MilvusClientV2Impl::AddCollectionFunction(const AddCollectionFunctionRequest& request) {
+    if (request.Function() == nullptr) {
+        return {StatusCode::INVALID_ARGUMENT, "Function cannot be null."};
+    }
+    if (request.Function()->Name().empty()) {
+        return {StatusCode::INVALID_ARGUMENT, "Function name cannot be empty."};
+    }
+
+    auto pre = [&request](proto::milvus::AddCollectionFunctionRequest& rpc_request) {
+        rpc_request.set_db_name(request.DatabaseName());
+        rpc_request.set_collection_name(request.CollectionName());
+        ConvertFunctionSchema(request.Function(), *rpc_request.mutable_functionschema());
+        return Status::OK();
+    };
+
+    return connection_.Invoke<proto::milvus::AddCollectionFunctionRequest, proto::common::Status>(
+        pre, &MilvusConnection::AddCollectionFunction);
+}
+
+Status
+MilvusClientV2Impl::AlterCollectionFunction(const AlterCollectionFunctionRequest& request) {
+    if (request.Function() == nullptr) {
+        return {StatusCode::INVALID_ARGUMENT, "Function cannot be null."};
+    }
+    if (request.Function()->Name().empty()) {
+        return {StatusCode::INVALID_ARGUMENT, "Function name cannot be empty."};
+    }
+
+    auto pre = [&request](proto::milvus::AlterCollectionFunctionRequest& rpc_request) {
+        rpc_request.set_db_name(request.DatabaseName());
+        rpc_request.set_collection_name(request.CollectionName());
+        rpc_request.set_function_name(request.Function()->Name());
+        ConvertFunctionSchema(request.Function(), *rpc_request.mutable_functionschema());
+        return Status::OK();
+    };
+
+    return connection_.Invoke<proto::milvus::AlterCollectionFunctionRequest, proto::common::Status>(
+        pre, &MilvusConnection::AlterCollectionFunction);
+}
+
+Status
+MilvusClientV2Impl::DropCollectionFunction(const DropCollectionFunctionRequest& request) {
+    if (request.FunctionName().empty()) {
+        return {StatusCode::INVALID_ARGUMENT, "Function name cannot be empty."};
+    }
+
+    auto pre = [&request](proto::milvus::DropCollectionFunctionRequest& rpc_request) {
+        rpc_request.set_db_name(request.DatabaseName());
+        rpc_request.set_collection_name(request.CollectionName());
+        rpc_request.set_function_name(request.FunctionName());
+        return Status::OK();
+    };
+
+    return connection_.Invoke<proto::milvus::DropCollectionFunctionRequest, proto::common::Status>(
+        pre, &MilvusConnection::DropCollectionFunction);
+}
+
 Status
 MilvusClientV2Impl::CreatePartition(const CreatePartitionRequest& request) {
     auto pre = [&request](proto::milvus::CreatePartitionRequest& rpc_request) {

src/impl/MilvusClientV2Impl.h

@@ -102,6 +102,15 @@ class MilvusClientV2Impl : public MilvusClientV2 {
     Status
     AddCollectionField(const AddCollectionFieldRequest& request) final;
 
+    Status
+    AddCollectionFunction(const AddCollectionFunctionRequest& request) final;
+
+    Status
+    AlterCollectionFunction(const AlterCollectionFunctionRequest& request) final;
+
+    Status
+    DropCollectionFunction(const DropCollectionFunctionRequest& request) final;
+
     Status
     CreatePartition(const CreatePartitionRequest& request) final;
 

src/impl/MilvusConnection.cpp

@@ -327,6 +327,24 @@ MilvusConnection::AddCollectionField(const proto::milvus::AddCollectionFieldRequ
     return grpcCall("AddCollectionField", &Stub::AddCollectionField, request, response, options);
 }
 
+Status
+MilvusConnection::AddCollectionFunction(const proto::milvus::AddCollectionFunctionRequest& request,
+                                        proto::common::Status& response, const GrpcContextOptions& options) {
+    return grpcCall("AddCollectionFunction", &Stub::AddCollectionFunction, request, response, options);
+}
+
+Status
+MilvusConnection::AlterCollectionFunction(const proto::milvus::AlterCollectionFunctionRequest& request,
+                                          proto::common::Status& response, const GrpcContextOptions& options) {
+    return grpcCall("AlterCollectionFunction", &Stub::AlterCollectionFunction, request, response, options);
+}
+
+Status
+MilvusConnection::DropCollectionFunction(const proto::milvus::DropCollectionFunctionRequest& request,
+                                         proto::common::Status& response, const GrpcContextOptions& options) {
+    return grpcCall("DropCollectionFunction", &Stub::DropCollectionFunction, request, response, options);
+}
+
 Status
 MilvusConnection::CreatePartition(const proto::milvus::CreatePartitionRequest& request, proto::common::Status& response,
                                   const GrpcContextOptions& options) {

src/impl/MilvusConnection.h

@@ -154,6 +154,18 @@ class MilvusConnection {
     AddCollectionField(const proto::milvus::AddCollectionFieldRequest& request, proto::common::Status& response,
                        const GrpcContextOptions& options);
 
+    Status
+    AddCollectionFunction(const proto::milvus::AddCollectionFunctionRequest& request, proto::common::Status& response,
+                          const GrpcContextOptions& options);
+
+    Status
+    AlterCollectionFunction(const proto::milvus::AlterCollectionFunctionRequest& request,
+                            proto::common::Status& response, const GrpcContextOptions& options);
+
+    Status
+    DropCollectionFunction(const proto::milvus::DropCollectionFunctionRequest& request, proto::common::Status& response,
+                           const GrpcContextOptions& options);
+
     Status
     CreatePartition(const proto::milvus::CreatePartitionRequest& request, proto::common::Status& response,
                     const GrpcContextOptions& options);

src/impl/request/collection/AddCollectionFunctionRequest.cpp

@@ -0,0 +1,37 @@
+// 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.
+
+#include "milvus/request/collection/AddCollectionFunctionRequest.h"
+
+namespace milvus {
+
+const FunctionPtr&
+AddCollectionFunctionRequest::Function() const {
+    return function_;
+}
+
+void
+AddCollectionFunctionRequest::SetFunction(const FunctionPtr& function) {
+    function_ = function;
+}
+
+AddCollectionFunctionRequest&
+AddCollectionFunctionRequest::WithFunction(const FunctionPtr& function) {
+    SetFunction(function);
+    return *this;
+}
+
+}  // namespace milvus

src/impl/request/collection/AlterCollectionFunctionRequest.cpp

@@ -0,0 +1,37 @@
+// 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.
+
+#include "milvus/request/collection/AlterCollectionFunctionRequest.h"
+
+namespace milvus {
+
+const FunctionPtr&
+AlterCollectionFunctionRequest::Function() const {
+    return function_;
+}
+
+void
+AlterCollectionFunctionRequest::SetFunction(const FunctionPtr& function) {
+    function_ = function;
+}
+
+AlterCollectionFunctionRequest&
+AlterCollectionFunctionRequest::WithFunction(const FunctionPtr& function) {
+    SetFunction(function);
+    return *this;
+}
+
+}  // namespace milvus

src/impl/request/collection/DropCollectionFunctionRequest.cpp

@@ -0,0 +1,39 @@
+// 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.
+
+#include "milvus/request/collection/DropCollectionFunctionRequest.h"
+
+#include <utility>
+
+namespace milvus {
+
+const std::string&
+DropCollectionFunctionRequest::FunctionName() const {
+    return function_name_;
+}
+
+void
+DropCollectionFunctionRequest::SetFunctionName(std::string function_name) {
+    function_name_ = std::move(function_name);
+}
+
+DropCollectionFunctionRequest&
+DropCollectionFunctionRequest::WithFunctionName(std::string function_name) {
+    SetFunctionName(std::move(function_name));
+    return *this;
+}
+
+}  // namespace milvus

src/include/milvus/MilvusClientV2.h

@@ -23,12 +23,15 @@
 #include "request/alias/DropAliasRequest.h"
 #include "request/alias/ListAliasesRequest.h"
 #include "request/collection/AddCollectionFieldRequest.h"
+#include "request/collection/AddCollectionFunctionRequest.h"
 #include "request/collection/AlterCollectionFieldPropertiesRequest.h"
+#include "request/collection/AlterCollectionFunctionRequest.h"
 #include "request/collection/AlterCollectionPropertiesRequest.h"
 #include "request/collection/CreateCollectionRequest.h"
 #include "request/collection/CreateSimpleCollectionRequest.h"
 #include "request/collection/DescribeCollectionRequest.h"
 #include "request/collection/DropCollectionFieldPropertiesRequest.h"
+#include "request/collection/DropCollectionFunctionRequest.h"
 #include "request/collection/DropCollectionPropertiesRequest.h"
 #include "request/collection/DropCollectionRequest.h"
 #include "request/collection/GetCollectionStatsRequest.h"
@@ -371,6 +374,34 @@ class MilvusClientV2 {
     virtual Status
     AddCollectionField(const AddCollectionFieldRequest& request) = 0;
 
+    /**
+     * @brief Add a function to an existing collection.
+     *
+     * @param [in] request input parameters
+     * @return Status operation successfully or not
+     */
+    virtual Status
+    AddCollectionFunction(const AddCollectionFunctionRequest& request) = 0;
+
+    /**
+     * @brief Alter a function of an existing collection. The function name
+     * (taken from the Function object) identifies which function to alter.
+     *
+     * @param [in] request input parameters
+     * @return Status operation successfully or not
+     */
+    virtual Status
+    AlterCollectionFunction(const AlterCollectionFunctionRequest& request) = 0;
+
+    /**
+     * @brief Drop a function of an existing collection.
+     *
+     * @param [in] request input parameters
+     * @return Status operation successfully or not
+     */
+    virtual Status
+    DropCollectionFunction(const DropCollectionFunctionRequest& request) = 0;
+
     /**
      * @brief Create a partition in a collection.
      *

src/include/milvus/request/collection/AddCollectionFunctionRequest.h

@@ -0,0 +1,56 @@
+// 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.
+
+#pragma once
+
+#include "../../types/Function.h"
+#include "./CollectionRequestBase.h"
+
+namespace milvus {
+
+/**
+ * @brief Used by MilvusClientV2::AddCollectionFunction()
+ */
+class AddCollectionFunctionRequest : public CollectionRequestBase<AddCollectionFunctionRequest> {
+ public:
+    /**
+     * @brief Constructor
+     */
+    AddCollectionFunctionRequest() = default;
+
+    /**
+     * @brief Get the function to be added.
+     */
+    const FunctionPtr&
+    Function() const;
+
+    /**
+     * @brief Set the function to be added.
+     */
+    void
+    SetFunction(const FunctionPtr& function);
+
+    /**
+     * @brief Set the function to be added.
+     */
+    AddCollectionFunctionRequest&
+    WithFunction(const FunctionPtr& function);
+
+ private:
+    FunctionPtr function_;
+};
+
+}  // namespace milvus