Generate scalar-first tbigint arithmetic operators via hex-WKB serialization

CMakeLists.txt

@@ -239,6 +239,13 @@ endif ()
 
 add_custom_target(build_all_plugins)
 
+# Declared here so add_compile_definitions reaches all sibling nes-* targets.
+# nes-plugins/CMakeLists.txt re-declares the same option (no-op when cached).
+option(NES_ENABLE_MEOS "Enable MEOS plugin (requires libmeos installed on the system)" ON)
+if(NES_ENABLE_MEOS)
+    add_compile_definitions(NES_ENABLE_MEOS)
+endif()
+
 # Add target for common lib, which contains a minimal set
 # of shared functionality used by all components of nes
 file(GLOB NES_DIRECTORIES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "nes-*")

flake.nix

@@ -54,6 +54,8 @@
           tbb
           python3
           openjdk21
+          paho-mqtt-c
+          paho-mqtt-cpp
         ]) ++ [ follyPkg antlr4Pkg ];
 
         antlr4Jar = pkgs.fetchurl {
@@ -244,6 +246,7 @@
             "-DNES_ENABLES_TESTS=ON"
             "-DCMAKE_MODULE_PATH=${libdwarfModule}/share/cmake/Modules"
             "-DANTLR4_JAR_LOCATION=${antlr4Jar}"
+            "-DNES_ENABLE_MEOS=OFF"
           ];
 
           enableParallelBuilding = true;
@@ -347,6 +350,7 @@
               "-DLLVM_DIR=${commonCmakeEnv.LLVM_DIR}"
               "-DANTLR4_JAR_LOCATION=${antlr4Jar}"
               "-DCMAKE_MODULE_PATH=${libdwarfModule}/share/cmake/Modules"
+              "-DNES_ENABLE_MEOS=OFF"
             ];
             shellHook = ''
               unset NES_PREBUILT_VCPKG_ROOT

nes-logical-operators/include/Functions/Meos/AddBigintTbigintLogicalFunction.hpp

@@ -0,0 +1,53 @@
+/*
+    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
+
+        https://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 <Functions/LogicalFunction.hpp>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace NES {
+
+/**
+ * @brief Per-event add_bigint_tbigint: a scalar constant and a hex-WKB temporal number -> hex-WKB temporal (scalar-first MEOS arg order).
+ *
+ * Generated by tools/codegen/codegen_nebula.py from the MEOS function
+ * `add_bigint_tbigint`. Per-event scalar operator following the
+ * TemporalEDWithinGeometry pattern.
+ */
+class AddBigintTbigintLogicalFunction : public LogicalFunctionConcept {
+public:
+    static constexpr std::string_view NAME = "AddBigintTbigint";
+
+    AddBigintTbigintLogicalFunction(LogicalFunction traj,
+                                          LogicalFunction arg0);
+
+    DataType getDataType() const override;
+    LogicalFunction withDataType(const DataType& dataType) const override;
+    std::vector<LogicalFunction> getChildren() const override;
+    LogicalFunction withChildren(const std::vector<LogicalFunction>& children) const override;
+    std::string_view getType() const override;
+    bool operator==(const LogicalFunctionConcept& rhs) const override;
+    std::string explain(ExplainVerbosity verbosity) const override;
+    LogicalFunction withInferredDataType(const Schema& schema) const override;
+    SerializableFunction serialize() const override;
+
+private:
+    DataType dataType;
+    std::vector<LogicalFunction> parameters;
+};
+
+} // namespace NES

nes-logical-operators/include/Functions/Meos/DivBigintTbigintLogicalFunction.hpp

@@ -0,0 +1,53 @@
+/*
+    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
+
+        https://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 <Functions/LogicalFunction.hpp>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace NES {
+
+/**
+ * @brief Per-event div_bigint_tbigint: a scalar constant and a hex-WKB temporal number -> hex-WKB temporal (scalar-first MEOS arg order).
+ *
+ * Generated by tools/codegen/codegen_nebula.py from the MEOS function
+ * `div_bigint_tbigint`. Per-event scalar operator following the
+ * TemporalEDWithinGeometry pattern.
+ */
+class DivBigintTbigintLogicalFunction : public LogicalFunctionConcept {
+public:
+    static constexpr std::string_view NAME = "DivBigintTbigint";
+
+    DivBigintTbigintLogicalFunction(LogicalFunction traj,
+                                          LogicalFunction arg0);
+
+    DataType getDataType() const override;
+    LogicalFunction withDataType(const DataType& dataType) const override;
+    std::vector<LogicalFunction> getChildren() const override;
+    LogicalFunction withChildren(const std::vector<LogicalFunction>& children) const override;
+    std::string_view getType() const override;
+    bool operator==(const LogicalFunctionConcept& rhs) const override;
+    std::string explain(ExplainVerbosity verbosity) const override;
+    LogicalFunction withInferredDataType(const Schema& schema) const override;
+    SerializableFunction serialize() const override;
+
+private:
+    DataType dataType;
+    std::vector<LogicalFunction> parameters;
+};
+
+} // namespace NES

nes-logical-operators/include/Functions/Meos/MulBigintTbigintLogicalFunction.hpp

@@ -0,0 +1,53 @@
+/*
+    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
+
+        https://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 <Functions/LogicalFunction.hpp>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace NES {
+
+/**
+ * @brief Per-event mul_bigint_tbigint: a scalar constant and a hex-WKB temporal number -> hex-WKB temporal (scalar-first MEOS arg order).
+ *
+ * Generated by tools/codegen/codegen_nebula.py from the MEOS function
+ * `mul_bigint_tbigint`. Per-event scalar operator following the
+ * TemporalEDWithinGeometry pattern.
+ */
+class MulBigintTbigintLogicalFunction : public LogicalFunctionConcept {
+public:
+    static constexpr std::string_view NAME = "MulBigintTbigint";
+
+    MulBigintTbigintLogicalFunction(LogicalFunction traj,
+                                          LogicalFunction arg0);
+
+    DataType getDataType() const override;
+    LogicalFunction withDataType(const DataType& dataType) const override;
+    std::vector<LogicalFunction> getChildren() const override;
+    LogicalFunction withChildren(const std::vector<LogicalFunction>& children) const override;
+    std::string_view getType() const override;
+    bool operator==(const LogicalFunctionConcept& rhs) const override;
+    std::string explain(ExplainVerbosity verbosity) const override;
+    LogicalFunction withInferredDataType(const Schema& schema) const override;
+    SerializableFunction serialize() const override;
+
+private:
+    DataType dataType;
+    std::vector<LogicalFunction> parameters;
+};
+
+} // namespace NES

nes-logical-operators/include/Functions/Meos/SubBigintTbigintLogicalFunction.hpp

@@ -0,0 +1,53 @@
+/*
+    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
+
+        https://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 <Functions/LogicalFunction.hpp>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace NES {
+
+/**
+ * @brief Per-event sub_bigint_tbigint: a scalar constant and a hex-WKB temporal number -> hex-WKB temporal (scalar-first MEOS arg order).
+ *
+ * Generated by tools/codegen/codegen_nebula.py from the MEOS function
+ * `sub_bigint_tbigint`. Per-event scalar operator following the
+ * TemporalEDWithinGeometry pattern.
+ */
+class SubBigintTbigintLogicalFunction : public LogicalFunctionConcept {
+public:
+    static constexpr std::string_view NAME = "SubBigintTbigint";
+
+    SubBigintTbigintLogicalFunction(LogicalFunction traj,
+                                          LogicalFunction arg0);
+
+    DataType getDataType() const override;
+    LogicalFunction withDataType(const DataType& dataType) const override;
+    std::vector<LogicalFunction> getChildren() const override;
+    LogicalFunction withChildren(const std::vector<LogicalFunction>& children) const override;
+    std::string_view getType() const override;
+    bool operator==(const LogicalFunctionConcept& rhs) const override;
+    std::string explain(ExplainVerbosity verbosity) const override;
+    LogicalFunction withInferredDataType(const Schema& schema) const override;
+    SerializableFunction serialize() const override;
+
+private:
+    DataType dataType;
+    std::vector<LogicalFunction> parameters;
+};
+
+} // namespace NES

nes-logical-operators/src/Functions/Meos/AddBigintTbigintLogicalFunction.cpp

@@ -0,0 +1,125 @@
+/*
+    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
+
+        https://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 <Functions/Meos/AddBigintTbigintLogicalFunction.hpp>
+
+#include <DataTypes/DataType.hpp>
+#include <DataTypes/DataTypeProvider.hpp>
+#include <DataTypes/Schema.hpp>
+#include <ErrorHandling.hpp>
+#include <LogicalFunctionRegistry.hpp>
+#include <Serialization/DataTypeSerializationUtil.hpp>
+#include <fmt/format.h>
+#include <SerializableVariantDescriptor.pb.h>
+
+namespace NES
+{
+
+AddBigintTbigintLogicalFunction::AddBigintTbigintLogicalFunction(LogicalFunction traj,
+                                          LogicalFunction arg0)
+    : dataType(DataTypeProvider::provideDataType(DataType::Type::VARSIZED))
+{
+    parameters.reserve(2);
+    parameters.push_back(std::move(traj));
+    parameters.push_back(std::move(arg0));
+}
+
+DataType AddBigintTbigintLogicalFunction::getDataType() const
+{
+    return dataType;
+}
+
+LogicalFunction AddBigintTbigintLogicalFunction::withDataType(const DataType& newDataType) const
+{
+    auto copy = *this;
+    copy.dataType = newDataType;
+    return copy;
+}
+
+std::vector<LogicalFunction> AddBigintTbigintLogicalFunction::getChildren() const
+{
+    return parameters;
+}
+
+LogicalFunction AddBigintTbigintLogicalFunction::withChildren(const std::vector<LogicalFunction>& children) const
+{
+    PRECONDITION(children.size() == 2, "AddBigintTbigintLogicalFunction requires 2 children, but got {}", children.size());
+    auto copy = *this;
+    copy.parameters = children;
+    return copy;
+}
+
+std::string_view AddBigintTbigintLogicalFunction::getType() const
+{
+    return NAME;
+}
+
+bool AddBigintTbigintLogicalFunction::operator==(const LogicalFunctionConcept& rhs) const
+{
+    if (const auto* other = dynamic_cast<const AddBigintTbigintLogicalFunction*>(&rhs))
+    {
+        return parameters == other->parameters;
+    }
+    return false;
+}
+
+std::string AddBigintTbigintLogicalFunction::explain(ExplainVerbosity verbosity) const
+{
+    std::string args;
+    for (size_t index = 0; index < parameters.size(); ++index)
+    {
+        if (index > 0)
+        {
+            args += ", ";
+        }
+        args += parameters[index].explain(verbosity);
+    }
+    return fmt::format("{}({})", NAME, args);
+}
+
+LogicalFunction AddBigintTbigintLogicalFunction::withInferredDataType(const Schema& schema) const
+{
+    std::vector<LogicalFunction> newChildren;
+    newChildren.reserve(parameters.size());
+    for (const auto& child : parameters)
+    {
+        newChildren.emplace_back(child.withInferredDataType(schema));
+    }
+    return withChildren(newChildren);
+}
+
+SerializableFunction AddBigintTbigintLogicalFunction::serialize() const
+{
+    SerializableFunction proto;
+    proto.set_function_type(std::string(NAME));
+    DataTypeSerializationUtil::serializeDataType(dataType, proto.mutable_data_type());
+    for (const auto& child : parameters)
+    {
+        proto.add_children()->CopyFrom(child.serialize());
+    }
+    return proto;
+}
+
+LogicalFunctionRegistryReturnType LogicalFunctionGeneratedRegistrar::RegisterAddBigintTbigintLogicalFunction(
+    LogicalFunctionRegistryArguments arguments)
+{
+    PRECONDITION(arguments.children.size() == 2,
+                 "AddBigintTbigintLogicalFunction requires 2 children but got {}",
+                 arguments.children.size());
+    auto arg0 = std::move(arguments.children[0]);
+    auto arg1 = std::move(arguments.children[1]);
+    return AddBigintTbigintLogicalFunction(std::move(arg0), std::move(arg1));
+}
+
+} // namespace NES

nes-logical-operators/src/Functions/Meos/CMakeLists.txt

@@ -18,3 +18,7 @@ add_plugin(TemporalAIntersectsGeometry LogicalFunction nes-logical-operators Tem
 add_plugin(TemporalEContainsGeometry LogicalFunction nes-logical-operators TemporalEContainsGeometryLogicalFunction.cpp)
 add_plugin(TemporalEDWithinGeometry LogicalFunction nes-logical-operators TemporalEDWithinGeometryLogicalFunction.cpp)
 add_plugin(TemporalAtStBox LogicalFunction nes-logical-operators TemporalAtStBoxLogicalFunction.cpp)
+add_plugin(AddBigintTbigint LogicalFunction nes-logical-operators AddBigintTbigintLogicalFunction.cpp)
+add_plugin(DivBigintTbigint LogicalFunction nes-logical-operators DivBigintTbigintLogicalFunction.cpp)
+add_plugin(MulBigintTbigint LogicalFunction nes-logical-operators MulBigintTbigintLogicalFunction.cpp)
+add_plugin(SubBigintTbigint LogicalFunction nes-logical-operators SubBigintTbigintLogicalFunction.cpp)