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

src/engine/QueryPlanner.cpp

@@ -1641,6 +1641,13 @@
     return {makeSubtreePlan<OptionalJoin>(_qec, a._qet, b._qet)};
   }
 
+  // Check if one of the two Operations is a SERVICE. If so, we can try
+  // to simplify the Service Query using the result of the other operation.
+  if (auto opt = createJoinWithService(a, b, jcs)) {
+    candidates.push_back(std::move(opt.value()));
+    return candidates;
+  }
+
   if (jcs.size() >= 2) {
     // If there are two or more join columns and we are not using the
     // TwoColumnJoin (the if part before this comment), use a multiColumnJoin.
@@ -1669,11 +1676,6 @@
     candidates.push_back(std::move(opt.value()));
   }
 
-  if (auto opt = createJoinWithService(a, b, jcs)) {
-    candidates.push_back(std::move(opt.value()));
-    return candidates;
-  }
-
   // Test if one of `a` or `b` is a transitive path to which we can bind the
   // other one.
   if (auto opt = createJoinWithTransitivePath(a, b, jcs)) {
@@ -1783,20 +1785,24 @@
   auto bRootOp = std::dynamic_pointer_cast<Service>(b._qet->getRootOperation());
 
   // Exactly one of the two Operations can be a service.
-  if (aRootOp == bRootOp) {
+  if (static_cast<bool>(aRootOp) == static_cast<bool>(bRootOp)) {
     return std::nullopt;
   }
 
   auto service = aRootOp ? aRootOp : bRootOp;
   auto sibling = bRootOp ? a : b;
 
   service->setSiblingTree(sibling._qet);
 
-  SubtreePlan plan = makeSubtreePlan<Join>(
-      service->getExecutionContext(), a._qet, b._qet, jcs[0][0], jcs[0][1]);
+  const auto& qec = service->getExecutionContext();
+
+  SubtreePlan plan =
+      jcs.size() == 1
+          ? makeSubtreePlan<Join>(qec, a._qet, b._qet, jcs[0][0], jcs[0][1])
+          : makeSubtreePlan<MultiColumnJoin>(qec, a._qet, b._qet);
   mergeSubtreePlanIds(plan, a, b);
 
   return plan;
 }
 
 // _____________________________________________________________________

src/engine/Service.cpp

@@ -97,11 +97,12 @@
   serviceIriString.remove_suffix(1);
   ad_utility::httpUtils::Url serviceUrl{serviceIriString};
 
-  // Try to optimize the Service Clause using it's sibling Operation.
+  // Try to simplify the Service Query using it's sibling Operation.
   if (auto valuesClause = getSiblingValuesClause(); valuesClause.has_value()) {
+    auto openBracketPos = parsedServiceClause_.graphPatternAsString_.find('{');
     parsedServiceClause_.graphPatternAsString_ =
-        "{ " + valuesClause.value() +
-        parsedServiceClause_.graphPatternAsString_.substr(2);
+        "{\n" + valuesClause.value() + '\n' +
+        parsedServiceClause_.graphPatternAsString_.substr(openBracketPos + 1);
   }
 
   // Construct the query to be sent to the SPARQL endpoint.
@@ -171,6 +172,7 @@
   return {std::move(idTable), resultSortedOn(), std::move(localVocab)};
 }
 
+// ____________________________________________________________________________
 std::optional<std::string> Service::getSiblingValuesClause() const {
   if (siblingTree_ == nullptr) {
     return std::nullopt;
@@ -179,44 +181,44 @@
   const auto& siblingResult = siblingTree_->getResult();
   if (siblingResult->size() >
       RuntimeParameters().get<"service-max-value-rows">()) {
     return std::nullopt;
   }
 
   std::vector<ColumnIndex> commonColumnIndices;
   const auto& siblingVars = siblingTree_->getVariableColumns();
-  std::string vars = "";
+  std::string vars = "(";
   for (const auto& localVar : parsedServiceClause_.visibleVariables_) {
     auto it = siblingVars.find(localVar);
     if (it == siblingVars.end()) {
       continue;
     }
     vars += it->first.name() + " ";
     commonColumnIndices.push_back(it->second.columnIndex_);
   }
-  vars.pop_back();
-  if (commonColumnIndices.size() > 1) {
-    vars = "(" + vars + ")";
-  }
+  vars.back() = ')';
+
+  ad_utility::HashSet<std::string> rowSet;
 
   std::string values = " { ";
   for (size_t rowIndex = 0; rowIndex < siblingResult->size(); ++rowIndex) {
-    std::string row;
+    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 += " ";
-        }
+        row += optionalString.value().first + ' ';
       }
     }
-    if (commonColumnIndices.size() > 1) {
-      row = "(" + row + ")";
+    row.back() = ')';
+
+    if (rowSet.contains(row)) {
+      continue;
     }
+
+    rowSet.insert(row);
     values += row + " ";
   }
 

src/engine/Service.h

@@ -60,9 +60,11 @@
           GetTsvFunction getTsvFunction = sendHttpOrHttpsRequest,
           std::shared_ptr<QueryExecutionTree> siblingTree = nullptr);
 
-  inline void setSiblingTree(std::shared_ptr<QueryExecutionTree> siblingTree) {
+  // Set the siblingTree (subTree that will later be joined with the Result of
+  // the Service Operation), used to reduce the Service Queries Complexity.
+  void setSiblingTree(std::shared_ptr<QueryExecutionTree> siblingTree) {
     siblingTree_ = siblingTree;
   }
 
   // Methods inherited from base class `Operation`.
   std::string getDescriptor() const override;
@@ -90,6 +92,7 @@
   // Compute the result using `getTsvFunction_`.
   ResultTable computeResult() override;
 
+  // Get a VALUES clause that contains the values of the siblingTree's result.
   std::optional<std::string> getSiblingValuesClause() const;
 
   // Write the given TSV result to the given result object. The `I` is the width