feat: expose the Go expr parser to C++ and embed into libmilvus-core.so (milvus-io#45703)

generated a library that wraps the go expr parser, and embedded that
into libmilvus-core.so

issue: milvus-io#45702

see `internal/core/src/plan/milvus_plan_parser.h` for the exposed
interface

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **New Features**
* Introduced C++ API for plan parsing with schema registration and
expression parsing capabilities.
* Plan parser now available as shared libraries instead of a standalone
binary tool.

* **Refactor**
* Reorganized build system to produce shared library artifacts instead
of executable binaries.
* Build outputs relocated to standardized library and include
directories.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Signed-off-by: Buqian Zheng <zhengbuqian@gmail.com>

Author: zhengbuqian

Makefile

@@ -386,15 +386,21 @@ run-test-cpp:
 	@echo $(PWD)/scripts/run_cpp_unittest.sh arg=${filter}
 	@(env bash $(PWD)/scripts/run_cpp_unittest.sh arg=${filter})
 
-# tool for benchmark
-exprparser-tool:
-	@echo "Building exprparser helper ..."
+plan-parser-so:
+	@echo "Building plan parser shared library ..."
 	@source $(PWD)/scripts/setenv.sh && \
-		mkdir -p $(INSTALL_PATH) && go env -w CGO_ENABLED="1" && \
-		GO111MODULE=on $(GO) build -pgo=$(PGO_PATH)/default.pgo -ldflags="-r $${RPATH}" -o $(INSTALL_PATH)/exprparser $(PWD)/cmd/tools/exprparser/main.go 1>/dev/null
+		mkdir -p $(PWD)/internal/core/output/lib $(PWD)/internal/core/output/include && \
+		go env -w CGO_ENABLED="1" && \
+		GO111MODULE=on $(GO) build -buildmode=c-shared -o $(PWD)/internal/core/output/lib/libmilvus-planparser.so $(PWD)/internal/parser/planparserv2/cwrapper/wrapper.go && \
+		mv $(PWD)/internal/core/output/lib/libmilvus-planparser.h $(PWD)/internal/core/output/include/libmilvus-planparser.h && \
+		cp $(PWD)/internal/parser/planparserv2/cwrapper/milvus_plan_parser.h $(PWD)/internal/core/output/include/ && \
+		g++ -shared -fPIC -o $(PWD)/internal/core/output/lib/libmilvus-planparser-cpp.so $(PWD)/internal/parser/planparserv2/cwrapper/milvus_plan_parser.cpp \
+			-I$(PWD)/internal/core/output/include \
+			-L$(PWD)/internal/core/output/lib -lmilvus-planparser \
+			-Wl,-rpath,'$$ORIGIN'
 
 # Build unittest with external scalar-benchmark enabled
-scalar-bench: generated-proto exprparser-tool
+scalar-bench: generated-proto plan-parser-so
 	@echo "Building Milvus cpp unittest with scalar-benchmark ... "
 	@(export CMAKE_EXTRA_ARGS="-DENABLE_SCALAR_BENCH=ON"; env bash $(PWD)/scripts/core_build.sh -t ${mode} -a ${use_asan} -u -n ${use_disk_index} -y ${use_dynamic_simd} ${AZURE_OPTION} -x ${index_engine} -o ${use_opendal} -f $(tantivy_features))
 

cmd/tools/exprparser/main.go

@@ -0,0 +1,86 @@
+// Copyright (C) 2019-2025 Zilliz. All rights reserved.
+//
+// Licensed 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
+
+//go:build exclude
+
+#include "milvus_plan_parser.h"
+
+#include <cstring>
+#include <stdexcept>
+
+// This header is generated by the Go build (cgo)
+// and is expected to be available in the include path.
+extern "C" {
+    #include "libmilvus-planparser.h"
+}
+
+namespace milvus {
+namespace planparserv2 {
+
+SchemaHandle PlanParser::RegisterSchema(const std::vector<uint8_t>& schema_proto) {
+    void* proto_blob = const_cast<void*>(static_cast<const void*>(schema_proto.data()));
+    int len = static_cast<int>(schema_proto.size());
+    char* err_msg = nullptr;
+
+    SchemaHandle handle = ::RegisterSchema(proto_blob, len, &err_msg);
+    if (handle == kInvalidSchemaHandle) {
+        std::string err_str = "Unknown error";
+        if (err_msg != nullptr) {
+            err_str = std::string(err_msg);
+            ::Free(err_msg);
+        }
+        throw std::runtime_error("Failed to register schema: " + err_str);
+    }
+
+    return handle;
+}
+
+std::string PlanParser::UnregisterSchema(SchemaHandle handle) {
+    char* err_msg = nullptr;
+
+    int result = ::UnregisterSchema(handle, &err_msg);
+    if (result != 0) {
+        std::string err = err_msg ? std::string(err_msg) : "unknown error";
+        if (err_msg != nullptr) {
+            ::Free(err_msg);
+        }
+        return err;
+    }
+    return "";
+}
+
+std::vector<uint8_t> PlanParser::Parse(SchemaHandle handle, const std::string& expr) {
+    char* c_expr = const_cast<char*>(expr.c_str());
+    char* err_msg = nullptr;
+    int length = 0;
+
+    void* result = ::Parse(handle, c_expr, &length, &err_msg);
+    if (result == nullptr) {
+        std::string err_str = "Unknown error";
+        if (err_msg != nullptr) {
+            err_str = std::string(err_msg);
+            ::Free(err_msg);
+        }
+        throw std::runtime_error("Failed to parse expression: " + err_str);
+    }
+
+    std::vector<uint8_t> plan(length);
+    if (length > 0) {
+        std::memcpy(plan.data(), result, length);
+    }
+
+    ::Free(result);
+
+    return plan;
+}
+
+} // namespace planparserv2
+} // namespace milvus

internal/parser/planparserv2/cwrapper/milvus_plan_parser.cpp

@@ -0,0 +1,80 @@
+// Copyright (C) 2019-2025 Zilliz. All rights reserved.
+//
+// Licensed 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 <cstdint>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace planparserv2 {
+
+// SchemaHandle is an opaque handle to a registered schema.
+// Valid handles are > 0. A handle of 0 indicates an invalid/unregistered schema.
+using SchemaHandle = int64_t;
+
+constexpr SchemaHandle kInvalidSchemaHandle = 0;
+
+// Thread-safe wrapper for the Go plan parser.
+//
+// Thread safety guarantees:
+// - RegisterSchema: Can be called concurrently. Each call returns a unique handle.
+// - UnregisterSchema: Can be called concurrently. Returns error if schema is in use or already unregistered.
+// - Parse: Can be called concurrently. Uses lock-free reference counting internally.
+//
+// Usage:
+//   auto handle = PlanParser::RegisterSchema(schema_proto);
+//   auto plan = PlanParser::Parse(handle, "field > 10");
+//   PlanParser::UnregisterSchema(handle);
+class PlanParser {
+public:
+    /**
+     * @brief Register a schema to the plan parser.
+     *
+     * Thread-safe. Each call returns a unique handle, even for identical schemas.
+     * The same schema can be registered multiple times, each with a different handle.
+     *
+     * @param schema_proto The serialized CollectionSchema protobuf.
+     * @return SchemaHandle A unique handle for the registered schema (> 0).
+     * @throws std::runtime_error if registration fails (e.g., invalid protobuf).
+     */
+    static SchemaHandle RegisterSchema(const std::vector<uint8_t>& schema_proto);
+
+    /**
+     * @brief Unregister a schema from the plan parser.
+     *
+     * Thread-safe. Fails if the schema is currently being used by Parse() or already unregistered.
+     *
+     * @param handle The handle returned by RegisterSchema.
+     * @return Empty string on success, error message on failure.
+     */
+    static std::string UnregisterSchema(SchemaHandle handle);
+
+    /**
+     * @brief Parse an expression string into a serialized PlanNode protobuf.
+     *
+     * Thread-safe and lock-free. Multiple threads can call Parse() concurrently
+     * with the same or different handles.
+     *
+     * @param handle The handle returned by RegisterSchema.
+     * @param expr The expression string to parse.
+     * @return std::vector<uint8_t> The serialized PlanNode protobuf.
+     * @throws std::runtime_error if:
+     *   - handle is invalid or not found
+     *   - schema was unregistered
+     *   - parsing fails
+     */
+    static std::vector<uint8_t> Parse(SchemaHandle handle, const std::string& expr);
+};
+
+} // namespace planparserv2
+} // namespace milvus