Add a VALUES clause to the query of a SERVICE clause to simplify the execution

src/engine/Service.cpp

@@ -5,12 +5,14 @@
 #include "engine/Service.h"
 
 #include <absl/strings/str_cat.h>
+#include <absl/strings/str_join.h>
 #include <absl/strings/str_split.h>
 
 #include "engine/CallFixedSize.h"
 #include "engine/ExportQueryExecutionTrees.h"
 #include "engine/Values.h"
 #include "engine/VariableToColumnMap.h"
+#include "global/RuntimeParameters.h"
 #include "parser/TokenizerCtre.h"
 #include "parser/TurtleParser.h"
 #include "util/Exception.h"
@@ -95,42 +97,11 @@ ResultTable Service::computeResult() {
   serviceIriString.remove_suffix(1);
   ad_utility::httpUtils::Url serviceUrl{serviceIriString};
 
-  if (siblingTree_ != nullptr) {
-    // Get the result of the siblingTree, to (potentially)
-    // reduce complexity of the SERVICE query.
-    auto siblingResult = siblingTree_->getResult();
-
-    const size_t rowLimit = 100;
-    if (siblingResult->size() < rowLimit) {
-      auto siblingVariables = siblingTree_->getVariableColumns();
-
-      // Build value clause for each common variable.
-      std::string valueClauses = "{ ";
-      for (const auto& lVar : parsedServiceClause_.visibleVariables_) {
-        auto it = siblingVariables.find(lVar);
-        if (it == siblingVariables.end()) {
-          continue;
-        }
-        const auto& sVar = *it;
-
-        valueClauses += "VALUES " + sVar.first.name() + " { ";
-        for (size_t rowIndex = 0; rowIndex < siblingResult->size();
-             ++rowIndex) {
-          const auto& optionalString =
-              ExportQueryExecutionTrees::idToStringAndType(
-                  siblingTree_->getRootOperation()->getIndex(),
-                  siblingResult->idTable()(rowIndex, sVar.second.columnIndex_),
-                  siblingResult->localVocab());
-          if (optionalString.has_value()) {
-            valueClauses += optionalString.value().first + " ";
-          }
-        }
-        valueClauses += "} . ";
-      }
-
-      parsedServiceClause_.graphPatternAsString_ =
-          valueClauses + parsedServiceClause_.graphPatternAsString_.substr(2);
-    }
+  // Try to optimize the Service Clause using it's sibling Operation.
+  if (auto valuesClause = getSiblingValuesClause(); valuesClause.has_value()) {
+    parsedServiceClause_.graphPatternAsString_ =
+        "{ " + valuesClause.value() +
+        parsedServiceClause_.graphPatternAsString_.substr(2);
   }
 
   // Construct the query to be sent to the SPARQL endpoint.
@@ -200,6 +171,57 @@ ResultTable Service::computeResult() {
   return {std::move(idTable), resultSortedOn(), std::move(localVocab)};
 }
 
+std::optional<std::string> Service::getSiblingValuesClause() const {
+  if (siblingTree_ == nullptr) {
+    return std::nullopt;
+  }
+
+  auto siblingResult = siblingTree_->getResult();
+  if (siblingResult->size() >
+      RuntimeParameters().get<"service-max-value-rows">()) {
+    return std::nullopt;
+  }
+
+  std::vector<ColumnIndex> commonColumnIndices;
+  auto siblingVariables = siblingTree_->getVariableColumns();
+  std::string vars = "";
+  for (const auto& localVar : parsedServiceClause_.visibleVariables_) {
+    auto it = siblingVariables.find(localVar);
+    if (it == siblingVariables.end()) {
+      continue;
+    }
+    vars += it->first.name() + " ";
+    commonColumnIndices.push_back(it->second.columnIndex_);
+  }
+  vars.pop_back();
+  if (commonColumnIndices.size() > 1) {
+    vars = "(" + vars + ")";
+  }
+
+  std::string valuesClause = " { ";
+  for (size_t rowIndex = 0; rowIndex < siblingResult->size(); ++rowIndex) {
+    std::string row;
+    for (size_t i = 0; i < commonColumnIndices.size(); ++i) {
+      const auto& optionalString = ExportQueryExecutionTrees::idToStringAndType(
+          siblingTree_->getRootOperation()->getIndex(),
+          siblingResult->idTable()(rowIndex, commonColumnIndices[i]),
+          siblingResult->localVocab());
+      if (optionalString.has_value()) {
+        row += optionalString.value().first;
+        if (i < commonColumnIndices.size() - 1) {
+          row += " ";
+        }
+      }
+    }
+    if (commonColumnIndices.size() > 1) {
+      row = "(" + row + ")";
+    }
+    valuesClause += row + " ";
+  }
+
+  return "VALUES " + vars + valuesClause + "} . ";
+}
+
 // ____________________________________________________________________________
 template <size_t I>
 void Service::writeTsvResult(cppcoro::generator<std::string_view> tsvResult,

src/engine/Service.h

@@ -86,6 +86,8 @@ class Service : public Operation {
   // Compute the result using `getTsvFunction_`.
   ResultTable computeResult() override;
 
+  std::optional<std::string> getSiblingValuesClause() const;
+
   // Write the given TSV result to the given result object. The `I` is the width
   // of the result table.
   //

src/global/RuntimeParameters.h

@@ -46,7 +46,8 @@ inline auto& RuntimeParameters() {
                 30s}),
         SizeT<"lazy-index-scan-max-size-materialization">{1'000'000},
         Bool<"use-binsearch-transitive-path">{true},
-        Bool<"group-by-hash-map-enabled">{false}};
+        Bool<"group-by-hash-map-enabled">{false},
+        SizeT<"service-max-value-rows">{100}};
   }();
   return params;
 }

test/ServiceTest.cpp

@@ -213,8 +213,7 @@ TEST_F(ServiceTest, computeResult) {
 
   std::string_view expectedSparqlQuery5 =
       "PREFIX doof: <http://doof.org> SELECT ?x ?y "
-      "WHERE { VALUES ?x { <x> <blu> } . VALUES ?y { <y> <bla> } . "
-      "?x <ble> ?y . }";
+      "WHERE { VALUES (?x ?y) { (<x> <y>) (<blu> <bla>) } . ?x <ble> ?y . }";
 
   Service serviceOperation5{
       testQec, parsedServiceClause5,