Parse complete SPARQL queries using ANTLR

CMakeLists.txt

@@ -38,8 +38,8 @@ if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
 endif ()
 
 if (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") AND
-   (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12") AND
-   (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.1"))
+(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12") AND
+(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.2"))
     message(STATUS "Adding -Wno-restrict for g++12.0 because of false positives")
     add_compile_options(-Wno-restrict)
     else()

src/engine/Server.cpp

@@ -646,7 +646,7 @@ boost::asio::awaitable<void> Server::processQuery(
               << (pinResult ? " [pin result]" : "")
               << (pinSubtrees ? " [pin subresults]" : "") << "\n"
               << query << std::endl;
-    ParsedQuery pq = SparqlParser(query).parse();
+    ParsedQuery pq = SparqlParser::parseQuery(query);
 
     // The following code block determines the media type to be used for the
     // result. The media type is either determined by the "Accept:" header of

src/parser/ParsedQuery.cpp

@@ -22,16 +22,6 @@ using std::vector;
 string ParsedQuery::asString() const {
   std::ostringstream os;
 
-  // PREFIX
-  os << "PREFIX: {";
-  for (size_t i = 0; i < _prefixes.size(); ++i) {
-    os << "\n\t" << _prefixes[i].asString();
-    if (i + 1 < _prefixes.size()) {
-      os << ',';
-    }
-  }
-  os << "\n}";
-
   bool usesSelect = hasSelectClause();
   bool usesAsterisk = usesSelect && selectClause().isAsterisk();
 
@@ -130,6 +120,22 @@ Variable ParsedQuery::addInternalBind(
 
 // ________________________________________________________________________
 void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
+  auto checkUsedVariablesAreVisible =
+      [this](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.");
+          }
+        }
+      };
+
   // 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.
@@ -219,6 +225,8 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
   // Process limitOffsetClause
   _limitOffset = modifiers.limitOffset_;
 
+  // Check that the query is valid
+
   auto checkAliasOutNamesHaveNoOverlapWith =
       [this](const auto& container, const std::string& message) {
         for (const auto& alias : selectClause().getAliases()) {
@@ -228,8 +236,6 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
         }
       };
 
-  // Check that the query is valid
-
   if (hasSelectClause()) {
     if (!_groupByVariables.empty()) {
       ad_utility::HashSet<string> groupVariables{};
@@ -287,15 +293,31 @@ void ParsedQuery::addSolutionModifiers(SolutionModifiers modifiers) {
         throw ParseException("The variable name " + a._target.name() +
                              " used in an alias was already selected on.");
       }
-      // TODO<qup42, joka921> Check that all variables used in the expression of
-      //  Aliases are visible in the QueryBody.
+
+      checkUsedVariablesAreVisible(a._expression, "Alias");
+    }
+  } else if (hasConstructClause()) {
+    if (_groupByVariables.empty()) {
+      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() + ".");
+          }
+        }
+      }
     }
   }
 }
 
 void ParsedQuery::merge(const ParsedQuery& p) {
-  _prefixes.insert(_prefixes.begin(), p._prefixes.begin(), p._prefixes.end());
-
   auto& children = _rootGraphPattern._graphPatterns;
   auto& otherChildren = p._rootGraphPattern._graphPatterns;
   children.insert(children.end(), otherChildren.begin(), otherChildren.end());

src/parser/ParsedQuery.h

@@ -92,9 +92,6 @@ class ParsedQuery {
 
   ParsedQuery() = default;
 
-  // The ql prefix for QLever specific additions is always defined.
-  vector<SparqlPrefix> _prefixes = {SparqlPrefix(
-      INTERNAL_PREDICATE_PREFIX_NAME, INTERNAL_PREDICATE_PREFIX_IRI)};
   GraphPattern _rootGraphPattern;
   vector<SparqlFilter> _havingClauses;
   size_t _numGraphPatterns = 1;

src/parser/SparqlParser.cpp

@@ -19,99 +19,16 @@ SparqlParser::SparqlParser(const string& query) : lexer_(query), query_(query) {
   LOG(DEBUG) << "Parsing " << query << std::endl;
 }
 
-namespace {
-// Converts the PrefixMap to the legacy data format used by ParsedQuery
-vector<SparqlPrefix> convertPrefixMap(
-    const SparqlQleverVisitor::PrefixMap& map) {
-  vector<SparqlPrefix> prefixes;
-  for (auto const& [label, iri] : map) {
-    prefixes.emplace_back(label, iri);
-  }
-  return prefixes;
-}
-}  // namespace
-
-// _____________________________________________________________________________
-ParsedQuery SparqlParser::parse() {
-  ParsedQuery result;
-  std::string originalString = query_;
-  // parsePrologue parses all the prefixes which are stored in a member
-  // PrefixMap. This member is returned on parse.
-  SparqlQleverVisitor::PrefixMap prefixes = parseWithAntlr(
-      &AntlrParser::prologue,
-      {{INTERNAL_PREDICATE_PREFIX_NAME, INTERNAL_PREDICATE_PREFIX_IRI}});
-
-  if (lexer_.accept("construct")) {
-    result._originalString = std::move(originalString);
-    result._prefixes = convertPrefixMap(prefixes);
-    parseQuery(&result, CONSTRUCT_QUERY);
-  } else if (lexer_.peek("select")) {
-    result = parseWithAntlr(&AntlrParser::selectQuery, prefixes);
-    result._originalString = std::move(originalString);
-    result._prefixes = convertPrefixMap(prefixes);
-  } else {
-    throw ParseException("Query must either be a SELECT or CONSTRUCT.");
+ParsedQuery SparqlParser::parseQuery(std::string_view query) {
+  sparqlParserHelpers::ParserAndVisitor p{
+      query, {{INTERNAL_PREDICATE_PREFIX_NAME, INTERNAL_PREDICATE_PREFIX_IRI}}};
+  auto resultOfParseAndRemainingText = p.parseTypesafe(&AntlrParser::query);
+  if (!resultOfParseAndRemainingText.remainingText_.empty()) {
+    // TODO: add Exception Metadata
+    throw ParseException("Query couldn't be parsed completely. Trailing: " +
+                         resultOfParseAndRemainingText.remainingText_);
   }
-  lexer_.expectEmpty();
-
-  return result;
-}
-
-// _____________________________________________________________________________
-void SparqlParser::parseQuery(ParsedQuery* query, QueryType queryType) {
-  AD_CHECK(queryType == CONSTRUCT_QUERY);
-  query->_clause = parseWithAntlr(&AntlrParser::constructTemplate, *query)
-                       .value_or(ad_utility::sparql_types::Triples{});
-
-  parseWhere(query);
-
-  parseSolutionModifiers(query);
-
-  if (query->_groupByVariables.empty()) {
-    return;
-  }
-
-  AD_CHECK(query->hasConstructClause());
-  auto& constructClause = query->constructClause();
-  for (const auto& triple : constructClause) {
-    for (const auto& varOrTerm : triple) {
-      if (auto variable = std::get_if<Variable>(&varOrTerm)) {
-        if (!ad_utility::contains(query->_groupByVariables, *variable)) {
-          throw ParseException("Variable " + variable->name() +
-                               " is used but not "
-                               "aggregated despite the query not being "
-                               "grouped by " +
-                               variable->name() + ".\n" + lexer_.input());
-        }
-      }
-    }
-  }
-}
-
-// _____________________________________________________________________________
-SparqlQleverVisitor::PrefixMap SparqlParser::getPrefixMap(
-    const ParsedQuery& parsedQuery) {
-  SparqlQleverVisitor::PrefixMap prefixMap;
-  for (const auto& prefixDef : parsedQuery._prefixes) {
-    prefixMap[prefixDef._prefix] = prefixDef._uri;
-  }
-  return prefixMap;
-}
-
-// _____________________________________________________________________________
-void SparqlParser::parseWhere(ParsedQuery* query) {
-  auto [pattern, visibleVariables] =
-      parseWithAntlr(&AntlrParser::whereClause, *query);
-  query->_rootGraphPattern = std::move(pattern);
-  query->registerVariablesVisibleInQueryBody(visibleVariables);
-}
-
-// _____________________________________________________________________________
-void SparqlParser::parseSolutionModifiers(ParsedQuery* query) {
-  query->addSolutionModifiers(
-      parseWithAntlr(&AntlrParser::solutionModifier, *query));
-
-  lexer_.accept("}");
+  return std::move(resultOfParseAndRemainingText.resultOfParse_);
 }
 
 // _____________________________________________________________________________
@@ -324,32 +241,6 @@ SparqlFilter SparqlParser::parseRegexFilter(bool expectKeyword) {
   return f;
 }
 
-// ________________________________________________________________________
-template <typename ContextType>
-auto SparqlParser::parseWithAntlr(
-    ContextType* (SparqlAutomaticParser::*F)(void),
-    const ParsedQuery& parsedQuery)
-    -> decltype((std::declval<sparqlParserHelpers::ParserAndVisitor>())
-                    .parseTypesafe(F)
-                    .resultOfParse_) {
-  return parseWithAntlr(F, getPrefixMap(parsedQuery));
-}
-
-// ________________________________________________________________________
-template <typename ContextType>
-auto SparqlParser::parseWithAntlr(
-    ContextType* (SparqlAutomaticParser::*F)(void),
-    SparqlQleverVisitor::PrefixMap prefixMap)
-    -> decltype((std::declval<sparqlParserHelpers::ParserAndVisitor>())
-                    .parseTypesafe(F)
-                    .resultOfParse_) {
-  sparqlParserHelpers::ParserAndVisitor p{lexer_.getUnconsumedInput(),
-                                          std::move(prefixMap)};
-  auto resultOfParseAndRemainingText = p.parseTypesafe(F);
-  lexer_.reset(std::move(resultOfParseAndRemainingText.remainingText_));
-  return std::move(resultOfParseAndRemainingText.resultOfParse_);
-}
-
 namespace {
 // The legacy way of expanding prefixes in an IRI. Currently used only by
 // `parserFilterExpression` below.

src/parser/SparqlParser.h

@@ -15,14 +15,12 @@
 
 using std::string;
 
-enum QueryType { CONSTRUCT_QUERY, SELECT_QUERY };
-
 // A simple parser of SPARQL.
 // No supposed to feature the complete query language.
 class SparqlParser {
  public:
   explicit SparqlParser(const string& query);
-  ParsedQuery parse();
+  static ParsedQuery parseQuery(std::string_view query);
 
   /// Parse the expression of a filter statement (without the `FILTER` keyword).
   /// This helper method is needed as long as the set of expressions supported
@@ -32,34 +30,10 @@ class SparqlParser {
       const SparqlQleverVisitor::PrefixMap& prefixMap);
 
  private:
-  void parseQuery(ParsedQuery* query, QueryType queryType);
-  void parseWhere(ParsedQuery* query);
-  void parseSolutionModifiers(ParsedQuery* query);
   // Returns true if it found a filter
   std::optional<SparqlFilter> parseFilter(bool failOnNoFilter = true);
 
   SparqlLexer lexer_;
   string query_;
   SparqlFilter parseRegexFilter(bool expectKeyword);
-
-  // Helper function that converts the prefix map from `parsedQuery` (a vector
-  // of pairs of prefix and IRI) to the prefix map we need for the
-  // `SparqlQleverVisitor` (a hash map from prefixes to IRIs).
-  static SparqlQleverVisitor::PrefixMap getPrefixMap(
-      const ParsedQuery& parsedQuery);
-  // Parse the clause with the prefixes of the given ParsedQuery.
-  template <typename ContextType>
-  auto parseWithAntlr(ContextType* (SparqlAutomaticParser::*F)(void),
-                      const ParsedQuery& parsedQuery)
-      -> decltype((std::declval<sparqlParserHelpers::ParserAndVisitor>())
-                      .parseTypesafe(F)
-                      .resultOfParse_);
-
-  // Parse the clause with the given explicitly specified prefixes.
-  template <typename ContextType>
-  auto parseWithAntlr(ContextType* (SparqlAutomaticParser::*F)(void),
-                      SparqlQleverVisitor::PrefixMap prefixMap)
-      -> decltype((std::declval<sparqlParserHelpers::ParserAndVisitor>())
-                      .parseTypesafe(F)
-                      .resultOfParse_);
 };

src/parser/SparqlParserHelpers.cpp

@@ -10,8 +10,8 @@ namespace sparqlParserHelpers {
 using std::string;
 
 // _____________________________________________________________________________
-ParserAndVisitor::ParserAndVisitor(string input)
-    : input_{std::move(input)}, visitor_{} {
+ParserAndVisitor::ParserAndVisitor(string_view input)
+    : input_{input}, visitor_{} {
   // The default in ANTLR is to log all errors to the console and to continue
   // the parsing. We need to turn parse errors into exceptions instead to
   // propagate them to the user.
@@ -22,9 +22,9 @@ ParserAndVisitor::ParserAndVisitor(string input)
 }
 
 // _____________________________________________________________________________
-ParserAndVisitor::ParserAndVisitor(string input,
+ParserAndVisitor::ParserAndVisitor(string_view input,
                                    SparqlQleverVisitor::PrefixMap prefixes)
-    : ParserAndVisitor{std::move(input)} {
+    : ParserAndVisitor{input} {
   visitor_.setPrefixMapManually(std::move(prefixes));
 }
 }  // namespace sparqlParserHelpers

src/parser/SparqlParserHelpers.h

@@ -28,7 +28,7 @@ struct ResultOfParseAndRemainingText {
 
 struct ParserAndVisitor {
  private:
-  string input_;
+  string_view input_;
   antlr4::ANTLRInputStream stream_{input_};
   SparqlAutomaticLexer lexer_{&stream_};
   antlr4::CommonTokenStream tokens_{&lexer_};
@@ -37,8 +37,8 @@ struct ParserAndVisitor {
  public:
   SparqlAutomaticParser parser_{&tokens_};
   SparqlQleverVisitor visitor_;
-  explicit ParserAndVisitor(string input);
-  ParserAndVisitor(string input, SparqlQleverVisitor::PrefixMap prefixes);
+  explicit ParserAndVisitor(string_view input);
+  ParserAndVisitor(string_view input, SparqlQleverVisitor::PrefixMap prefixes);
 
   template <typename ContextType>
   auto parseTypesafe(ContextType* (SparqlAutomaticParser::*F)(void)) {