Implement functions UUID() and STRUUID()

src/engine/sparqlExpressions/UuidExpressions.h

@@ -0,0 +1,80 @@
+//  Copyright 2024, University of Freiburg,
+//                  Chair of Algorithms and Data Structures
+//  Author: Hannes Baumann <[email protected]>
+
+// Test for UuidExpressionImpl can be found in RandomExpressionTest.cpp
+
+#pragma once
+
+#include "engine/sparqlExpressions/SparqlExpression.h"
+#include "util/ChunkedForLoop.h"
+#include "util/Random.h"
+
+namespace sparqlExpression {
+namespace detail::uuidExpression {
+
+using LiteralOrIri = ad_utility::triple_component::LiteralOrIri;
+
+inline constexpr auto fromLiteral = [](std::string_view str) {
+  return LiteralOrIri{
+      ad_utility::triple_component::Literal::literalWithNormalizedContent(
+          asNormalizedStringViewUnsafe(str))};
+};
+
+inline constexpr auto fromIri = [](std::string_view str) {
+  return LiteralOrIri{
+      ad_utility::triple_component::Iri::fromStringRepresentation(
+          absl::StrCat("<urn:uuid:"sv, str, ">"sv))};
+};
+
+inline constexpr auto litUuidKey = [](int64_t randId) {
+  return absl::StrCat("STRUUID "sv, randId);
+};
+
+inline constexpr auto iriUuidKey = [](int64_t randId) {
+  return absl::StrCat("UUID "sv, randId);
+};
+
+// With UuidExpressionImpl<fromIri, iriUuidKey>, the UUIDs are returned as an
+// Iri object: <urn:uuid:b9302fb5-642e-4d3b-af19-29a8f6d894c9> (example). With
+// UuidExpressionImpl<fromLiteral,, litUuidKey>, the UUIDs are returned as an
+// Literal object: "73cd4307-8a99-4691-a608-b5bda64fb6c1" (example).
+template <auto FuncConv, auto FuncKey>
+class UuidExpressionImpl : public SparqlExpression {
+ private:
+  int64_t randId_ = ad_utility::FastRandomIntGenerator<int64_t>{}();
+
+ public:
+  ExpressionResult evaluate(EvaluationContext* context) const override {
+    VectorWithMemoryLimit<IdOrLiteralOrIri> result{context->_allocator};
+    const size_t numElements = context->_endIndex - context->_beginIndex;
+    result.reserve(numElements);
+    ad_utility::UuidGenerator uuidGen;
+
+    if (context->_isPartOfGroupBy) {
+      return FuncConv(uuidGen());
+    }
+
+    ad_utility::chunkedForLoop<1000>(
+        0, numElements,
+        [&result, &uuidGen](size_t) { result.push_back(FuncConv(uuidGen())); },
+        [context]() { context->cancellationHandle_->throwIfCancelled(); });
+    return result;
+  }
+
+  string getCacheKey(
+      [[maybe_unused]] const VariableToColumnMap& varColMap) const override {
+    return FuncKey(randId_);
+  }
+
+ private:
+  std::span<SparqlExpression::Ptr> childrenImpl() override { return {}; }
+};
+
+}  //  namespace detail::uuidExpression
+
+using namespace detail::uuidExpression;
+using UuidExpression = UuidExpressionImpl<fromIri, iriUuidKey>;
+using StrUuidExpression = UuidExpressionImpl<fromLiteral, litUuidKey>;
+
+}  // namespace sparqlExpression

src/parser/sparqlParser/SparqlQleverVisitor.cpp

@@ -17,6 +17,7 @@
 #include "engine/sparqlExpressions/RandomExpression.h"
 #include "engine/sparqlExpressions/RegexExpression.h"
 #include "engine/sparqlExpressions/RelationalExpressions.h"
+#include "engine/sparqlExpressions/UuidExpressions.h"
 #include "parser/SparqlParser.h"
 #include "parser/TokenizerCtre.h"
 #include "parser/TurtleParser.h"
@@ -2015,6 +2016,12 @@ ExpressionPtr Visitor::visit([[maybe_unused]] Parser::BuiltInCallContext* ctx) {
   } else if (functionName == "rand") {
     AD_CONTRACT_CHECK(argList.empty());
     return std::make_unique<RandomExpression>();
+  } else if (functionName == "uuid") {
+    AD_CONTRACT_CHECK(argList.empty());
+    return std::make_unique<UuidExpression>();
+  } else if (functionName == "struuid") {
+    AD_CONTRACT_CHECK(argList.empty());
+    return std::make_unique<StrUuidExpression>();
   } else if (functionName == "ceil") {
     return createUnary(&makeCeilExpression);
   } else if (functionName == "abs") {

src/util/Random.h

@@ -8,6 +8,8 @@
 
 #include <algorithm>
 #include <array>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
 #include <cstring>
 #include <random>
 #include <type_traits>
@@ -104,6 +106,20 @@ class RandomDoubleGenerator {
   std::uniform_real_distribution<double> _distribution;
 };
 
+// GENERATE UUID
+class UuidGenerator {
+ public:
+  explicit UuidGenerator(
+      RandomSeed seed = RandomSeed::make(std::random_device{}()))
+      : randomEngine_{seed.get()}, gen_(randomEngine_) {}
+
+  std::string operator()() { return boost::uuids::to_string(gen_()); }
+
+ private:
+  std::mt19937_64 randomEngine_;
+  boost::uuids::basic_random_generator<std::mt19937_64> gen_;
+};
+
 /// Randomly shuffle range denoted by `[begin, end)`
 template <typename RandomIt>
 void randomShuffle(RandomIt begin, RandomIt end,

test/RandomExpressionTest.cpp

@@ -2,8 +2,11 @@
 //                  Chair of Algorithms and Data Structures.
 //  Author: Johannes Kalmbach <[email protected]>
 
+#include <unordered_set>
+
 #include "./SparqlExpressionTestHelpers.h"
 #include "engine/sparqlExpressions/RandomExpression.h"
+#include "engine/sparqlExpressions/UuidExpressions.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -58,3 +61,89 @@ TEST(RandomExpression, simpleMemberFunctions) {
   // probability of `1 / 2^64` of a spurious failure.
   ASSERT_NE(cacheKey, RandomExpression{}.getCacheKey({}));
 }
+
+// The tests for UUID expressions follow almost exactly the pattern
+// of the above defined test for RandomExpression.
+TEST(UuidExpression, simpleMemberFunctionStrUuid) {
+  StrUuidExpression strUuid;
+  ASSERT_TRUE(strUuid.getUnaggregatedVariables().empty());
+  auto cacheKeyStrUuid = strUuid.getCacheKey({});
+  ASSERT_THAT(cacheKeyStrUuid, ::testing::StartsWith("STRUUID "));
+  ASSERT_EQ(cacheKeyStrUuid, strUuid.getCacheKey({}));
+  StrUuidExpression strUuid2;
+  ASSERT_NE(cacheKeyStrUuid, strUuid2.getCacheKey({}));
+}
+
+TEST(UuidExpression, simpleMemberFunctionLitUuid) {
+  UuidExpression iriUuid;
+  ASSERT_TRUE(iriUuid.getUnaggregatedVariables().empty());
+  auto cacheKeyIriUuid = iriUuid.getCacheKey({});
+  ASSERT_THAT(cacheKeyIriUuid, ::testing::StartsWith("UUID "));
+  ASSERT_EQ(cacheKeyIriUuid, iriUuid.getCacheKey({}));
+  UuidExpression iriUuid2;
+  ASSERT_NE(cacheKeyIriUuid, iriUuid2.getCacheKey({}));
+}
+
+TEST(UuidExpression, evaluateStrUuidExpression) {
+  TestContext testContext{};
+  auto& evaluationContext = testContext.context;
+  evaluationContext._beginIndex = 43;
+  evaluationContext._endIndex = 1044;
+  auto resultAsVariant = StrUuidExpression{}.evaluate(&evaluationContext);
+
+  using V = VectorWithMemoryLimit<IdOrLiteralOrIri>;
+  ASSERT_TRUE(std::holds_alternative<V>(resultAsVariant));
+  const auto& resultVector = std::get<V>(resultAsVariant);
+  ASSERT_EQ(resultVector.size(), 1001);
+
+  // check that none of the results equals all previous results
+  std::unordered_set<std::string> strUuids;
+  for (auto uuid : resultVector) {
+    ASSERT_TRUE(std::holds_alternative<LiteralOrIri>(uuid));
+    LiteralOrIri litUuid = std::get<LiteralOrIri>(uuid);
+    ASSERT_TRUE(litUuid.isLiteral());
+    std::string_view strUuid =
+        asStringViewUnsafe(litUuid.getLiteral().getContent());
+    ASSERT_EQ(strUuids.find(std::string(strUuid)), strUuids.end());
+    strUuids.insert(std::string(strUuid));
+  }
+
+  evaluationContext._isPartOfGroupBy = true;
+  auto resultAsVariant2 = StrUuidExpression{}.evaluate(&evaluationContext);
+  ASSERT_TRUE(std::holds_alternative<IdOrLiteralOrIri>(resultAsVariant2));
+  IdOrLiteralOrIri litOrIriUuid = std::get<IdOrLiteralOrIri>(resultAsVariant2);
+  ASSERT_TRUE(std::holds_alternative<LiteralOrIri>(litOrIriUuid));
+  ASSERT_TRUE(std::get<LiteralOrIri>(litOrIriUuid).isLiteral());
+}
+
+TEST(UuidExpression, evaluateUuidExpression) {
+  TestContext testContext{};
+  auto& evaluationContext = testContext.context;
+  evaluationContext._beginIndex = 43;
+  evaluationContext._endIndex = 1044;
+  auto resultAsVariant = UuidExpression{}.evaluate(&evaluationContext);
+
+  using V = VectorWithMemoryLimit<IdOrLiteralOrIri>;
+  ASSERT_TRUE(std::holds_alternative<V>(resultAsVariant));
+  const auto& resultVector = std::get<V>(resultAsVariant);
+  ASSERT_EQ(resultVector.size(), 1001);
+
+  // check that none of the results equals all of the other results
+  std::unordered_set<std::string> strUuids;
+  for (auto uuid : resultVector) {
+    ASSERT_TRUE(std::holds_alternative<LiteralOrIri>(uuid));
+    LiteralOrIri litUuid = std::get<LiteralOrIri>(uuid);
+    ASSERT_TRUE(litUuid.isIri());
+    std::string_view iriUuid =
+        asStringViewUnsafe(litUuid.getIri().getContent());
+    ASSERT_EQ(strUuids.find(std::string(iriUuid)), strUuids.end());
+    strUuids.insert(std::string(iriUuid));
+  }
+
+  evaluationContext._isPartOfGroupBy = true;
+  auto resultAsVariant2 = UuidExpression{}.evaluate(&evaluationContext);
+  ASSERT_TRUE(std::holds_alternative<IdOrLiteralOrIri>(resultAsVariant2));
+  IdOrLiteralOrIri litOrIriUuid = std::get<IdOrLiteralOrIri>(resultAsVariant2);
+  ASSERT_TRUE(std::holds_alternative<LiteralOrIri>(litOrIriUuid));
+  ASSERT_TRUE(std::get<LiteralOrIri>(litOrIriUuid).isIri());
+}

test/RandomTest.cpp

@@ -7,9 +7,11 @@
 #include <algorithm>
 #include <array>
 #include <concepts>
+#include <ctre.hpp>
 #include <random>
 #include <ranges>
 #include <type_traits>
+#include <unordered_set>
 
 #include "../test/util/RandomTestHelpers.h"
 #include "util/Exception.h"
@@ -235,4 +237,28 @@ TEST(RandomShuffleTest, Seed) {
       });
 }
 
+TEST(UuidGeneratorTest, StrUuidGeneratorTest) {
+  // Test few times that the returned UUID str is not
+  // "00000000-0000-0000-0000-000000000000" (nil-UUID)
+  // and that none of the str-UUIDS is rquivalent to the already
+  // created ones.
+  // Pattern for checking that UUID is properly formatted
+  static constexpr auto uuidPattern = ctll::fixed_string{
+      "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{"
+      "3}-[0-9a-fA-F]{12}$"};
+  boost::uuids::string_generator getUuid;
+  UuidGenerator gen = UuidGenerator();
+  std::unordered_set<std::string> setUuids;
+  size_t i = 0;
+  while (i < 100) {
+    std::string strUuid = gen();
+    boost::uuids::uuid uuid = getUuid(strUuid.data());
+    ASSERT_EQ(uuid.is_nil(), false);
+    ASSERT_EQ(setUuids.find(strUuid), setUuids.end());
+    ASSERT_TRUE(ctre::match<uuidPattern>(strUuid));
+    setUuids.insert(strUuid);
+    i++;
+  }
+}
+
 }  // namespace ad_utility

test/SparqlAntlrParserTest.cpp

@@ -20,6 +20,7 @@
 #include "engine/sparqlExpressions/LiteralExpression.h"
 #include "engine/sparqlExpressions/RandomExpression.h"
 #include "engine/sparqlExpressions/RegexExpression.h"
+#include "engine/sparqlExpressions/UuidExpressions.h"
 #include "parser/ConstructClause.h"
 #include "parser/SparqlParserHelpers.h"
 #include "parser/sparqlParser/SparqlQleverVisitor.h"
@@ -1397,6 +1398,8 @@ TEST(SparqlParser, builtInCall) {
   expectBuiltInCall("ISNUMERIC(?x)", matchUnary(&makeIsNumericExpression));
   expectBuiltInCall("BOUND(?x)", matchUnary(&makeBoundExpression));
   expectBuiltInCall("RAND()", matchPtr<RandomExpression>());
+  expectBuiltInCall("STRUUID()", matchPtr<StrUuidExpression>());
+  expectBuiltInCall("UUID()", matchPtr<UuidExpression>());
   expectBuiltInCall("COALESCE(?x)", matchUnary(makeCoalesceExpressionVariadic));
   expectBuiltInCall("COALESCE()", matchNary(makeCoalesceExpressionVariadic));
   expectBuiltInCall("COALESCE(?x, ?y, ?z)",