Parse complete SPARQL queries using ANTLR

src/engine/Server.cpp

@@ -437,8 +437,8 @@ Awaitable<json> Server::composeResponseQleverJson(
           query.hasSelectClause()
               ? qet.writeResultAsQLeverJson(query.selectClause(), limit, offset,
                                             std::move(resultTable))
-              : qet.writeRdfGraphJson(query.constructClause(), limit, offset,
-                                      std::move(resultTable));
+              : qet.writeRdfGraphJson(query.constructClause().triples_, limit,
+                                      offset, std::move(resultTable));
       requestTimer.stop();
     }
     j["resultsize"] = query.hasSelectClause() ? resultSize : j["res"].size();
@@ -510,11 +510,11 @@ Server::composeResponseSepValues(const ParsedQuery& query,
   auto compute = [&] {
     size_t limit = query._limitOffset._limit;
     size_t offset = query._limitOffset._offset;
-    return query.hasSelectClause()
-               ? qet.generateResults<format>(query.selectClause(), limit,
-                                             offset)
-               : qet.writeRdfGraphSeparatedValues<format>(
-                     query.constructClause(), limit, offset, qet.getResult());
+    return query.hasSelectClause() ? qet.generateResults<format>(
+                                         query.selectClause(), limit, offset)
+                                   : qet.writeRdfGraphSeparatedValues<format>(
+                                         query.constructClause().triples_,
+                                         limit, offset, qet.getResult());
   };
   return computeInNewThread(compute);
 }
@@ -530,8 +530,8 @@ ad_utility::streams::stream_generator Server::composeTurtleResponse(
   }
   size_t limit = query._limitOffset._limit;
   size_t offset = query._limitOffset._offset;
-  return qet.writeRdfGraphTurtle(query.constructClause(), limit, offset,
-                                 qet.getResult());
+  return qet.writeRdfGraphTurtle(query.constructClause().triples_, limit,
+                                 offset, qet.getResult());
 }
 
 // _____________________________________________________________________________

src/parser/CMakeLists.txt

@@ -19,6 +19,10 @@ add_library(parser
         SparqlParserHelpers.h SparqlParserHelpers.cpp
         TripleComponent.h
         GraphPatternOperation.cpp
-        PropertyPath.h PropertyPath.cpp Alias.h data/SolutionModifiers.h data/LimitOffsetClause.h data/SparqlFilter.h data/SparqlFilter.cpp data/OrderKey.h data/GroupKey.h ParseException.cpp SelectClause.cpp SelectClause.h GraphPatternOperation.cpp GraphPatternOperation.h GraphPattern.cpp GraphPattern.h)
+        PropertyPath.h PropertyPath.cpp Alias.h data/SolutionModifiers.h
+        data/LimitOffsetClause.h data/SparqlFilter.h data/SparqlFilter.cpp
+        data/OrderKey.h data/GroupKey.h ParseException.cpp SelectClause.cpp
+        SelectClause.h GraphPatternOperation.cpp GraphPatternOperation.h
+        GraphPattern.cpp GraphPattern.h ConstructClause.h)
 target_link_libraries(parser sparqlParser parserData sparqlExpressions rdfEscaping re2 absl::flat_hash_map util)
 

src/parser/ConstructClause.h

@@ -0,0 +1,30 @@
+//  Copyright 2022, University of Freiburg,
+//  Chair of Algorithms and Data Structures.
+//  Author: Julian Mundhahs ([email protected])
+
+#pragma once
+
+#include "parser/SelectClause.h"
+#include "parser/data/Types.h"
+
+namespace parsedQuery {
+struct ConstructClause : ClauseBase {
+  ad_utility::sparql_types::Triples triples_;
+
+  ConstructClause() = default;
+  explicit ConstructClause(ad_utility::sparql_types::Triples triples)
+      : triples_(std::move(triples)) {}
+
+  // Yields all variables that appear in this `ConstructClause`. Variables that
+  // appear multiple times are also yielded multiple times.
+  cppcoro::generator<const Variable> containedVariables() const {
+    for (const auto& triple : triples_) {
+      for (const auto& varOrTerm : triple) {
+        if (auto variable = std::get_if<Variable>(&varOrTerm)) {
+          co_yield *variable;
+        }
+      }
+    }
+  }
+};
+}  // namespace parsedQuery

src/parser/ParsedQuery.cpp

@@ -46,7 +46,7 @@ string ParsedQuery::asString() const {
       os << "{";
     }
   } else if (hasConstructClause()) {
-    const auto& constructClause = this->constructClause();
+    const auto& constructClause = this->constructClause().triples_;
     os << "\n CONSTRUCT {\n\t";
     for (const auto& triple : constructClause) {
       os << triple[0].toSparql();
@@ -120,40 +120,34 @@ Variable ParsedQuery::addInternalBind(
 
 // ________________________________________________________________________
 void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
+  auto checkVariableIsVisible = [this](const Variable& var,
+                                       const std::string& locationDescription) {
+    if (!ad_utility::contains(getVisibleVariables(), var)) {
+      throw ParseException("Variable " + var.name() + " was used in " +
+                           locationDescription +
+                           " is not visible in the Query Body.");
+    }
+  };
   auto checkUsedVariablesAreVisible =
-      [this](const sparqlExpression::SparqlExpressionPimpl& expression,
-             const std::string& locationDescription) {
+      [&checkVariableIsVisible](
+          const sparqlExpression::SparqlExpressionPimpl& expression,
+          const std::string& locationDescription) {
         for (const auto* var : expression.containedVariables()) {
-          // TODO: think of a solution to make this work with ConstructClause as
-          //  well.
-          if (!ad_utility::contains(selectClause().getVisibleVariables(),
-                                    *var)) {
-            throw ParseException("Variable " + var->name() + " used in " +
-                                 locationDescription +
-                                 expression.getDescriptor() +
-                                 " is not visible in the Query Body.");
-          }
+          checkVariableIsVisible(*var, locationDescription);
         }
       };
 
   // Process groupClause
-  // TODO<qup42, joka921> Check that all variables that are part of an
-  //  expression that is grouped on are visible in the Query Body.
-  auto processVariable = [this](const Variable& groupKey) {
-    // TODO: implement for `ConstructClause`
-    if (hasSelectClause()) {
-      if (!ad_utility::contains(selectClause().getVisibleVariables(),
-                                groupKey)) {
-        throw ParseException(
-            "Variable " + groupKey.name() +
-            " was used in an GROUP BY but is not visible in the query body.");
-      }
-    }
+  auto processVariable = [this,
+                          &checkVariableIsVisible](const Variable& groupKey) {
+    checkVariableIsVisible(groupKey, "GROUP BY");
 
     _groupByVariables.emplace_back(groupKey.name());
   };
   auto processExpression =
-      [this](sparqlExpression::SparqlExpressionPimpl groupKey) {
+      [this, &checkUsedVariablesAreVisible](
+          sparqlExpression::SparqlExpressionPimpl groupKey) {
+        checkUsedVariablesAreVisible(groupKey, "Group Key");
         auto helperTarget = addInternalBind(std::move(groupKey));
         _groupByVariables.emplace_back(helperTarget.name());
       };
@@ -176,18 +170,22 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
   _havingClauses = std::move(modifiers.havingClauses_);
 
   // Process orderClause
-  // TODO<qup42, joka921> Check that all variables that are part of an
-  //  expression that is ordered on are visible in the Query Body.
-  auto processVariableOrderKey = [this](VariableOrderKey orderKey) {
+  auto processVariableOrderKey = [this, &checkVariableIsVisible](
+                                     VariableOrderKey orderKey) {
     // Check whether grouping is done. The variable being ordered by
     // must then be either grouped or the result of an alias in the select.
     const vector<Variable>& groupByVariables = _groupByVariables;
-    if (!groupByVariables.empty() &&
-        !ad_utility::contains(groupByVariables, orderKey.variable_) &&
-        !ad_utility::contains_if(selectClause().getAliases(),
-                                 [&orderKey](const Alias& alias) {
-                                   return alias._target == orderKey.variable_;
-                                 })) {
+    if (groupByVariables.empty()) {
+      checkVariableIsVisible(orderKey.variable_, "ORDERY BY");
+    } else if (!ad_utility::contains(groupByVariables, orderKey.variable_) &&
+               // `ConstructClause` has no Aliases. So the variable can never be
+               // the result of an Alias.
+               (hasConstructClause() ||
+                !ad_utility::contains_if(selectClause().getAliases(),
+                                         [&orderKey](const Alias& alias) {
+                                           return alias._target ==
+                                                  orderKey.variable_;
+                                         }))) {
       throw ParseException(
           "Variable " + orderKey.variable_.name() +
           " was used in an ORDER BY "
@@ -201,8 +199,10 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
   // QLever currently only supports ordering by variables. To allow
   // all `orderConditions`, the corresponding expression is bound to a new
   // internal variable. Ordering is then done by this variable.
-  auto processExpressionOrderKey = [this](ExpressionOrderKey orderKey) {
-    if (!_groupByVariables.empty())
+  auto processExpressionOrderKey = [this, &checkUsedVariablesAreVisible](
+                                       ExpressionOrderKey orderKey) {
+    checkUsedVariablesAreVisible(orderKey.expression_, "Order Key");
+    if (!_groupByVariables.empty()) {
       // TODO<qup42> Implement this by adding a hidden alias in the
       //  SELECT clause.
       throw ParseException(
@@ -212,6 +212,7 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
           "\"). Please assign this expression to a "
           "new variable in the SELECT clause and then order by this "
           "variable.");
+    }
     auto additionalVariable = addInternalBind(std::move(orderKey.expression_));
     _orderBy.emplace_back(additionalVariable, orderKey.isDescending_);
   };
@@ -301,17 +302,13 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
       return;
     }
 
-    for (const auto& triple : constructClause()) {
-      for (const auto& varOrTerm : triple) {
-        if (auto variable = std::get_if<Variable>(&varOrTerm)) {
-          if (!ad_utility::contains(_groupByVariables, *variable)) {
-            throw ParseException("Variable " + variable->name() +
-                                 " is used but not "
-                                 "aggregated despite the query not being "
-                                 "grouped by " +
-                                 variable->name() + ".");
-          }
-        }
+    for (const auto& variable : constructClause().containedVariables()) {
+      if (!ad_utility::contains(_groupByVariables, variable)) {
+        throw ParseException("Variable " + variable.name() +
+                             " is used but not "
+                             "aggregated despite the query not being "
+                             "grouped by " +
+                             variable.name() + ".");
       }
     }
   }

src/parser/ParsedQuery.h

@@ -9,27 +9,28 @@
 #include <variant>
 #include <vector>
 
-#include "../engine/ResultType.h"
-#include "../engine/sparqlExpressions/SparqlExpressionPimpl.h"
-#include "../util/Algorithm.h"
-#include "../util/Exception.h"
-#include "../util/HashMap.h"
-#include "../util/OverloadCallOperator.h"
-#include "../util/StringUtils.h"
-#include "./TripleComponent.h"
-#include "Alias.h"
-#include "ParseException.h"
-#include "PropertyPath.h"
-#include "data/GroupKey.h"
-#include "data/LimitOffsetClause.h"
-#include "data/OrderKey.h"
-#include "data/SolutionModifiers.h"
-#include "data/SparqlFilter.h"
-#include "data/Types.h"
-#include "data/VarOrTerm.h"
+#include "engine/ResultType.h"
+#include "engine/sparqlExpressions/SparqlExpressionPimpl.h"
+#include "parser/Alias.h"
+#include "parser/ConstructClause.h"
 #include "parser/GraphPattern.h"
 #include "parser/GraphPatternOperation.h"
+#include "parser/ParseException.h"
+#include "parser/PropertyPath.h"
 #include "parser/SelectClause.h"
+#include "parser/TripleComponent.h"
+#include "parser/data/GroupKey.h"
+#include "parser/data/LimitOffsetClause.h"
+#include "parser/data/OrderKey.h"
+#include "parser/data/SolutionModifiers.h"
+#include "parser/data/SparqlFilter.h"
+#include "parser/data/Types.h"
+#include "parser/data/VarOrTerm.h"
+#include "util/Algorithm.h"
+#include "util/Exception.h"
+#include "util/HashMap.h"
+#include "util/OverloadCallOperator.h"
+#include "util/StringUtils.h"
 
 using std::string;
 using std::vector;
@@ -88,7 +89,7 @@ class ParsedQuery {
 
   using SelectClause = parsedQuery::SelectClause;
 
-  using ConstructClause = ad_utility::sparql_types::Triples;
+  using ConstructClause = parsedQuery::ConstructClause;
 
   ParsedQuery() = default;
 
@@ -131,22 +132,24 @@ class ParsedQuery {
     return std::get<ConstructClause>(_clause);
   }
 
-  // Add a variable, that was found in the SubQuery body, when query has a
-  // Select Clause.
-  bool registerVariableVisibleInQueryBody(const Variable& variable) {
-    if (!hasSelectClause()) return false;
-    selectClause().addVisibleVariable(variable);
-    return true;
+  // Add a variable, that was found in the SubQuery body.
+  void registerVariableVisibleInQueryBody(const Variable& variable) {
+    auto addVariable = [&variable](auto& clause) {
+      clause.addVisibleVariable(variable);
+    };
+    std::visit(addVariable, _clause);
   }
 
-  // Add variables, that were found in the SubQuery body, when query has a
-  // Select Clause.
-  bool registerVariablesVisibleInQueryBody(const vector<Variable>& variables) {
-    if (!hasSelectClause()) return false;
+  // Add variables, that were found in the SubQuery body.
+  void registerVariablesVisibleInQueryBody(const vector<Variable>& variables) {
     for (const auto& var : variables) {
-      selectClause().addVisibleVariable(var);
+      registerVariableVisibleInQueryBody(var);
     }
-    return true;
+  }
+
+  // Returns all variables that are visible in the Query Body.
+  const std::vector<Variable>& getVisibleVariables() {
+    return std::visit(&parsedQuery::ClauseBase::getVisibleVariables, _clause);
   }
 
   auto& children() { return _rootGraphPattern._graphPatterns; }

src/parser/SelectClause.cpp

@@ -9,6 +9,18 @@
 #include "util/OverloadCallOperator.h"
 
 using namespace parsedQuery;
+
+// ____________________________________________________________________
+void ClauseBase::addVisibleVariable(const Variable& variable) {
+  if (!ad_utility::contains(visibleVariables_, variable)) {
+    visibleVariables_.emplace_back(variable);
+  }
+}
+
+const vector<Variable>& ClauseBase::getVisibleVariables() {
+  return visibleVariables_;
+}
+
 // ____________________________________________________________________
 [[nodiscard]] bool SelectClause::isAsterisk() const {
   return std::holds_alternative<Asterisk>(varsAndAliasesOrAsterisk_);
@@ -42,17 +54,6 @@ void SelectClause::setSelected(std::vector<Variable> variables) {
   setSelected(v);
 }
 
-// ____________________________________________________________________
-void SelectClause::addVisibleVariable(const Variable& variable) {
-  if (!ad_utility::contains(visibleVariables_, variable)) {
-    visibleVariables_.emplace_back(variable);
-  }
-}
-
-const vector<Variable>& SelectClause::getVisibleVariables() {
-  return visibleVariables_;
-}
-
 // ____________________________________________________________________
 [[nodiscard]] const std::vector<Variable>& SelectClause::getSelectedVariables()
     const {