Implement CONSTRUCT query processing

src/engine/QueryExecutionTree.cpp

@@ -448,9 +448,9 @@ QueryExecutionTree::writeRdfGraphTurtle(
   for (size_t i = offset; i < upperBound; i++) {
     Context context{i, *res, variableColumns, _qec->getIndex()};
     for (const auto& triple : constructTriples) {
-      auto subject = triple[0].toString(context, SUBJECT);
-      auto verb = triple[1].toString(context, VERB);
-      auto object = triple[2].toString(context, OBJECT);
+      auto subject = triple[0].evaluate(context, SUBJECT);
+      auto verb = triple[1].evaluate(context, VERB);
+      auto object = triple[2].evaluate(context, OBJECT);
       if (!subject.has_value() || !verb.has_value() || !object.has_value()) {
         continue;
       }

src/engine/QueryPlanner.cpp

@@ -65,7 +65,8 @@ QueryExecutionTree QueryPlanner::createExecutionTree(ParsedQuery& pq) {
   if (doGrouping && !usePatternTrick) {
     plans.emplace_back(getGroupByRow(pq, plans));
   } else if (usePatternTrick) {
-    plans.emplace_back(getPatternTrickRow(pq, plans, patternTrickTriple));
+    plans.emplace_back(
+        getPatternTrickRow(pq.selectClause(), plans, patternTrickTriple));
   }
 
   // HAVING
@@ -897,9 +898,9 @@ vector<QueryPlanner::SubtreePlan> QueryPlanner::getDistinctRow(
 
 // _____________________________________________________________________________
 vector<QueryPlanner::SubtreePlan> QueryPlanner::getPatternTrickRow(
-    const ParsedQuery& pq, const vector<vector<SubtreePlan>>& dpTab,
+    const ParsedQuery::SelectClause& selectClause,
+    const vector<vector<SubtreePlan>>& dpTab,
     const SparqlTriple& patternTrickTriple) {
-  const auto& selectClause = pq.selectClause();
   const vector<SubtreePlan>* previous = nullptr;
   if (!dpTab.empty()) {
     previous = &dpTab.back();

src/engine/QueryPlanner.h

@@ -279,7 +279,8 @@ class QueryPlanner {
       const vector<vector<SubtreePlan>>& dpTab) const;
 
   vector<SubtreePlan> getPatternTrickRow(
-      const ParsedQuery& pq, const vector<vector<SubtreePlan>>& dpTab,
+      const ParsedQuery::SelectClause& selectClause,
+      const vector<vector<SubtreePlan>>& dpTab,
       const SparqlTriple& patternTrickTriple);
 
   vector<SubtreePlan> getHavingRow(

src/engine/Server.cpp

@@ -380,33 +380,31 @@ boost::asio::awaitable<void> Server::processQuery(
           request));
     }
 
+    const auto throwIfConstructClause = [&pq]() {
+      if (pq.hasConstructClause()) {
+        throw std::runtime_error{
+            "CONSTRUCT queries only support turtle syntax right now"};
+      }
+    };
+
     AD_CHECK(mediaType.has_value());
     switch (mediaType.value()) {
       case ad_utility::MediaType::csv: {
-        if (pq.hasConstructClause()) {
-          throw std::runtime_error{
-              "CONSTRUCT queries only support turtle syntax right now"};
-        }
+        throwIfConstructClause();
         auto responseGenerator = composeResponseSepValues(pq, qet, ',');
         auto response = createOkResponse(std::move(responseGenerator), request,
                                          ad_utility::MediaType::csv);
         co_await send(std::move(response));
       } break;
       case ad_utility::MediaType::tsv: {
-        if (pq.hasConstructClause()) {
-          throw std::runtime_error{
-              "CONSTRUCT queries only support turtle syntax right now"};
-        }
+        throwIfConstructClause();
         auto responseGenerator = composeResponseSepValues(pq, qet, '\t');
         auto response = createOkResponse(std::move(responseGenerator), request,
                                          ad_utility::MediaType::tsv);
         co_await send(std::move(response));
       } break;
       case ad_utility::MediaType::qleverJson: {
-        if (pq.hasConstructClause()) {
-          throw std::runtime_error{
-              "CONSTRUCT queries only support turtle syntax right now"};
-        }
+        throwIfConstructClause();
         // Normal case: JSON response
         auto responseString =
             composeResponseQleverJson(pq, qet, requestTimer, maxSend);

src/index/CMakeLists.txt

@@ -1,3 +1,4 @@
+
 add_library(index
         Index.h Index.cpp Index.Text.cpp
         Vocabulary.h Vocabulary.cpp
@@ -13,10 +14,4 @@ add_library(index
         PrefixHeuristic.cpp PrefixHeuristic.h
         CompressedRelation.h CompressedRelation.cpp)
 
-
-find_package(OpenMP)
-if(OpenMP_CXX_FOUND)
-    target_link_libraries(index parser ${STXXL_LIBRARIES} ${ICU_LIBRARIES} absl::flat_hash_map absl::flat_hash_set zstd OpenMP::OpenMP_CXX)
-else()
-    target_link_libraries(index parser ${STXXL_LIBRARIES} ${ICU_LIBRARIES} absl::flat_hash_map absl::flat_hash_set zstd)
-endif()
+target_link_libraries(index parser ${STXXL_LIBRARIES} ${ICU_LIBRARIES} absl::flat_hash_map absl::flat_hash_set zstd)

src/parser/ParsedQuery.cpp

@@ -59,11 +59,11 @@ string ParsedQuery::asString() const {
     const auto& constructClause = this->constructClause();
     os << "\n CONSTRUCT {\n\t";
     for (const auto& triple : constructClause) {
-      os << triple[0].toString();
+      os << triple[0].toSparql();
       os << ' ';
-      os << triple[1].toString();
+      os << triple[1].toSparql();
       os << ' ';
-      os << triple[2].toString();
+      os << triple[2].toSparql();
       os << " .\n";
     }
     os << "}";

src/parser/ParsedQuery.h

@@ -347,9 +347,11 @@ class ParsedQuery {
     return std::get<ConstructClause>(_clause);
   }
 
-  decltype(auto) selectClause() { return std::get<SelectClause>(_clause); }
+  [[nodiscard]] decltype(auto) selectClause() {
+    return std::get<SelectClause>(_clause);
+  }
 
-  decltype(auto) constructClause() {
+  [[nodiscard]] decltype(auto) constructClause() {
     return std::get<ConstructClause>(_clause);
   }
 

src/parser/SparqlParser.cpp

@@ -89,8 +89,8 @@ void SparqlParser::parseQuery(ParsedQuery* query, QueryType queryType) {
       auto& constructClause = query->constructClause();
       for (const auto& triple : constructClause) {
         for (const auto& varOrTerm : triple) {
-          if (std::holds_alternative<Variable>(varOrTerm)) {
-            const auto var = varOrTerm.toString();
+          if (auto variable = std::get_if<Variable>(&varOrTerm)) {
+            const auto var = variable->getName();
             if (std::find(query->_groupByVariables.begin(),
                           query->_groupByVariables.end(),
                           var) == query->_groupByVariables.end()) {
@@ -209,6 +209,8 @@ OrderKey SparqlParser::parseOrderKey(const std::string& order,
     _lexer.expect(")");
     s << ")";
   } else if (query->hasSelectClause() && _lexer.accept("(")) {
+    // TODO This assumes that aliases can stand in the ORDER BY
+    // This is not true, only expression may stand there
     ParsedQuery::Alias a = parseAliasWithAntlr();
     auto& selectClause = query->selectClause();
 

src/parser/SparqlParserHelpers.cpp

@@ -21,90 +21,55 @@ struct ParserAndVisitor {
  public:
   SparqlAutomaticParser _parser{&_tokens};
   SparqlQleverVisitor _visitor;
-  explicit ParserAndVisitor(string input) : _input{std::move(input)} {}
-  explicit ParserAndVisitor(string input,
-                            SparqlQleverVisitor::PrefixMap prefixMap)
-      : _input{std::move(input)}, _visitor{std::move(prefixMap)} {}
+  explicit ParserAndVisitor(string input) : _input{std::move(input)} {
+    _parser.setErrorHandler(std::make_shared<ThrowingErrorStrategy>());
+  }
 
   template <typename ResultType, typename ContextType>
-  auto parse(const std::string& input,
+  auto parse(const std::string& input, const std::string_view& name,
              ContextType* (SparqlAutomaticParser::*F)(void)) {
-    _parser.setErrorHandler(std::make_shared<ThrowingErrorStrategy>());
-    auto context = (_parser.*F)();
-    auto resultOfParse =
-        std::move(context->accept(&(_visitor)).template as<ResultType>());
+    try {
+      auto context = (_parser.*F)();
+      auto resultOfParse =
+          std::move(context->accept(&(_visitor)).template as<ResultType>());
 
-    auto remainingString =
-        input.substr(_parser.getCurrentToken()->getStartIndex());
-    return ResultOfParseAndRemainingText{std::move(resultOfParse),
-                                         std::move(remainingString)};
+      auto remainingString =
+          input.substr(_parser.getCurrentToken()->getStartIndex());
+      return ResultOfParseAndRemainingText{std::move(resultOfParse),
+                                           std::move(remainingString)};
+    } catch (const antlr4::ParseCancellationException& e) {
+      throw std::runtime_error{"Failed to parse " + name + ": " + e.what()};
+    }
   }
 };
 
 // ____________________________________________________________________________
 ResultOfParseAndRemainingText<sparqlExpression::SparqlExpressionPimpl>
 parseExpression(const std::string& input) {
-  try {
-    ParserAndVisitor p{input};
-    auto resultOfParseAndRemainingText =
-        p.parse<sparqlExpression::SparqlExpression::Ptr>(
-            input, &SparqlAutomaticParser::expression);
+  ParserAndVisitor p{input};
+  auto resultOfParseAndRemainingText =
+      p.parse<sparqlExpression::SparqlExpression::Ptr>(
+          input, "expression", &SparqlAutomaticParser::expression);
 
-    return ResultOfParseAndRemainingText{
-        sparqlExpression::SparqlExpressionPimpl{
-            std::move(resultOfParseAndRemainingText._resultOfParse)},
-        std::move(resultOfParseAndRemainingText._remainingText)};
-  } catch (const antlr4::ParseCancellationException& e) {
-    throw std::runtime_error{"Failed to parse expression: "s + e.what()};
-  }
+  return ResultOfParseAndRemainingText{
+      sparqlExpression::SparqlExpressionPimpl{
+          std::move(resultOfParseAndRemainingText._resultOfParse)},
+      std::move(resultOfParseAndRemainingText._remainingText)};
 }
 
 // ____________________________________________________________________________
 ResultOfParseAndRemainingText<ParsedQuery::Alias> parseAlias(
     const std::string& input) {
-  try {
-    ParserAndVisitor p{input};
-    return p.parse<ParsedQuery::Alias>(
-        input, &SparqlAutomaticParser::aliasWithouBrackes);
-  } catch (const antlr4::ParseCancellationException& e) {
-    throw std::runtime_error{"Failed to parse alias: "s + e.what()};
-  }
+  ParserAndVisitor p{input};
+  return p.parse<ParsedQuery::Alias>(
+      input, "alias", &SparqlAutomaticParser::aliasWithouBrackes);
 }
 // _____________________________________________________________________________
 
 ResultOfParseAndRemainingText<std::vector<std::array<VarOrTerm, 3>>>
 parseConstructTemplate(const std::string& input) {
-  try {
-    ParserAndVisitor p{input};
-    return p.parse<std::vector<std::array<VarOrTerm, 3>>>(
-        input, &SparqlAutomaticParser::constructTemplate);
-  } catch (const antlr4::ParseCancellationException& e) {
-    throw std::runtime_error{"Failed to parse construct template: "s +
-                             e.what()};
-  }
-}
-
-// ______________________________________________________________________________
-std::pair<SparqlQleverVisitor::PrefixMap, size_t> parsePrologue(
-    const string& input) {
   ParserAndVisitor p{input};
-  auto prologueContext = p._parser.prologue();
-  auto prologueSize = prologueContext->getText().size();
-  p._visitor.visitPrologue(prologueContext);
-  const auto& constVisitor = p._visitor;
-  return {constVisitor.prefixMap(), prologueSize};
+  return p.parse<std::vector<std::array<VarOrTerm, 3>>>(
+      input, "construct template", &SparqlAutomaticParser::constructTemplate);
 }
-
-// Parse a prefix of `input` as an iri, return the iri and the number of bytes
-// that were consumed from the `input`.
-std::pair<string, size_t> parseIri(const string& input,
-                                   SparqlQleverVisitor::PrefixMap prefixMap) {
-  ParserAndVisitor p{input, std::move(prefixMap)};
-  auto iriContext = p._parser.iri();
-  auto iriSize = iriContext->getText().size();
-  auto resultString = p._visitor.visitIri(iriContext).as<string>();
-  // const auto& constVisitor = p.visitor;
-  return {std::move(resultString), iriSize};
-}
-
-}  // namespace sparqlParserHelpers
+}  // namespace sparqlParserHelpers

src/parser/data/BlankNode.h

@@ -21,7 +21,7 @@ class BlankNode {
       : _generated{generated}, _label{std::move(label)} {}
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::optional<std::string> toString(
+  [[nodiscard]] std::optional<std::string> evaluate(
       const Context& context, [[maybe_unused]] ContextRole role) const {
     std::ostringstream stream;
     stream << "_:";
@@ -33,7 +33,7 @@ class BlankNode {
   }
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::string toString() const {
+  [[nodiscard]] std::string toSparql() const {
     std::ostringstream stream;
     stream << "_:";
     // generated or user-defined

src/parser/data/GraphTerm.h

@@ -19,20 +19,20 @@ class GraphTerm : public GraphTermBase {
   using GraphTermBase::GraphTermBase;
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::optional<std::string> toString(const Context& context,
+  [[nodiscard]] std::optional<std::string> evaluate(const Context& context,
                                                     ContextRole role) const {
     // TODO<C++23>: remove static_cast as soon as we can visit types that
     // inherit from std::variant
     return std::visit(
-        [&](const auto& object) { return object.toString(context, role); },
+        [&](const auto& object) { return object.evaluate(context, role); },
         static_cast<const GraphTermBase&>(*this));
   }
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::string toString() const {
+  [[nodiscard]] std::string toSparql() const {
     // TODO<C++23>: remove static_cast as soon as we can visit types that
     // inherit from std::variant
-    return std::visit([&](const auto& object) { return object.toString(); },
+    return std::visit([&](const auto& object) { return object.toSparql(); },
                       static_cast<const GraphTermBase&>(*this));
   }
 };

src/parser/data/Iri.h

@@ -20,12 +20,12 @@ class Iri {
   }
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::optional<std::string> toString(
+  [[nodiscard]] std::optional<std::string> evaluate(
       [[maybe_unused]] const Context& context,
       [[maybe_unused]] ContextRole role) const {
     return _string;
   }
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::string toString() const { return _string; }
+  [[nodiscard]] std::string toSparql() const { return _string; }
 };

src/parser/data/Literal.h

@@ -22,7 +22,7 @@ class Literal {
       : _stringRepresentation(toString(std::forward<decltype(t)>(t))) {}
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::optional<std::string> toString(
+  [[nodiscard]] std::optional<std::string> evaluate(
       [[maybe_unused]] const Context& context, ContextRole role) const {
     if (role == OBJECT) {
       return _stringRepresentation;
@@ -31,5 +31,5 @@ class Literal {
   }
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::string toString() const { return _stringRepresentation; }
+  [[nodiscard]] std::string toSparql() const { return _stringRepresentation; }
 };

src/parser/data/VarOrTerm.h

@@ -19,20 +19,20 @@ class VarOrTerm : public VarOrTermBase {
   using VarOrTermBase::VarOrTermBase;
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::optional<std::string> toString(const Context& context,
+  [[nodiscard]] std::optional<std::string> evaluate(const Context& context,
                                                     ContextRole role) const {
     // TODO<C++23>: remove static_cast as soon as we can visit types that
     // inherit from std::variant
     return std::visit(
-        [&](const auto& object) { return object.toString(context, role); },
+        [&](const auto& object) { return object.evaluate(context, role); },
         static_cast<const VarOrTermBase&>(*this));
   }
 
   // ___________________________________________________________________________
-  [[nodiscard]] std::string toString() const {
+  [[nodiscard]] std::string toSparql() const {
     // TODO<C++23>: remove static_cast as soon as we can visit types that
     // inherit from std::variant
-    return std::visit([&](const auto& object) { return object.toString(); },
+    return std::visit([&](const auto& object) { return object.toSparql(); },
                       static_cast<const VarOrTermBase&>(*this));
   }
 };