Parse WHERE clause using ANTLR

src/parser/sparqlParser/SparqlQleverVisitor.cpp

@@ -4,13 +4,12 @@
 //   Hannah Bast <[email protected]>
 //   2022 Julian Mundhahs <[email protected]>
 
-#include "SparqlQleverVisitor.h"
+#include <parser/SparqlParser.h>
+#include <parser/sparqlParser/SparqlQleverVisitor.h>
 
 #include <string>
 #include <vector>
 
-#include "../SparqlParser.h"
-
 using namespace ad_utility::sparql_types;
 using ExpressionPtr = sparqlExpression::SparqlExpression::Ptr;
 using SparqlExpressionPimpl = sparqlExpression::SparqlExpressionPimpl;
@@ -64,6 +63,14 @@ ExpressionPtr Visitor::processIriFunctionCall(
   throw ParseException{"Function \"" + iri + "\" not supported"};
 }
 
+void Visitor::addVisibleVariable(const string& var) {
+  addVisibleVariable(Variable{var});
+}
+
+void Visitor::addVisibleVariable(const Variable& var) {
+  visibleVariables_.back().emplace_back(var);
+}
+
 // ___________________________________________________________________________
 namespace {
 string stripAndLowercaseKeywordLiteral(std::string_view lit) {
@@ -182,7 +189,7 @@ Variable Visitor::visitTypesafe(Parser::VarContext* ctx) {
 
 // ____________________________________________________________________________________
 GraphPatternOperation Visitor::visitTypesafe(Parser::BindContext* ctx) {
-  visibleVariables_.back().emplace_back(ctx->var()->getText());
+  addVisibleVariable(ctx->var()->getText());
   return GraphPatternOperation{
       Bind{{visitTypesafe(ctx->expression())}, ctx->var()->getText()}};
 }
@@ -191,9 +198,9 @@ GraphPatternOperation Visitor::visitTypesafe(Parser::BindContext* ctx) {
 GraphPatternOperation Visitor::visitTypesafe(Parser::InlineDataContext* ctx) {
   Values values = visitTypesafe(ctx->dataBlock());
   for (const auto& variable : values._inlineValues._variables) {
-    visibleVariables_.back().emplace_back(variable);
+    addVisibleVariable(variable);
   }
-  return GraphPatternOperation{values};
+  return GraphPatternOperation{std::move(values)};
 }
 
 // ____________________________________________________________________________________
@@ -230,9 +237,8 @@ GraphPattern Visitor::visitTypesafe(Parser::GroupGraphPatternContext* ctx) {
   }
 }
 
-// TODO: Package this type into a struct.
-std::pair<vector<GraphPatternOperation>, vector<SparqlFilter>>
-Visitor::visitTypesafe(Parser::GroupGraphPatternSubContext* ctx) {
+Visitor::OperationsAndFilters Visitor::visitTypesafe(
+    Parser::GroupGraphPatternSubContext* ctx) {
   vector<GraphPatternOperation> ops;
   vector<SparqlFilter> filters;
 
@@ -244,46 +250,39 @@ Visitor::visitTypesafe(Parser::GroupGraphPatternSubContext* ctx) {
   };
 
   if (ctx->triplesBlock()) {
-    ops.emplace_back(GraphPatternOperation::BasicGraphPattern{
-        visitTypesafe(ctx->triplesBlock())});
+    ops.emplace_back(visitTypesafe(ctx->triplesBlock()));
   }
   auto others = visitVector<
       std::pair<variant<GraphPatternOperation, SparqlFilter>,
                 std::optional<GraphPatternOperation::BasicGraphPattern>>>(
       ctx->graphPatternNotTriplesAndMaybeTriples());
-  for (auto [variant, triples] : others) {
-    std::visit(ad_utility::OverloadCallOperator{filter, op}, variant);
-    if (triples.has_value()) {
-      if (holds_alternative<SparqlFilter>(variant) && !ops.empty() &&
-          holds_alternative<GraphPatternOperation::BasicGraphPattern>(
-              ops.back().variant_)) {
-        ad_utility::appendVector(
-            get<GraphPatternOperation::BasicGraphPattern>(ops.back().variant_)
-                ._whereClauseTriples,
-            std::move(triples.value()._whereClauseTriples));
-
-      } else {
-        ops.emplace_back(triples.value());
-      }
+  for (auto [graphPattern, triples] : others) {
+    std::visit(ad_utility::OverloadCallOperator{filter, op}, graphPattern);
+    if (!triples.has_value()) {
+      continue;
+    }
+    if (ops.empty() ||
+        !holds_alternative<GraphPatternOperation::BasicGraphPattern>(
+            ops.back().variant_)) {
+      ops.emplace_back(GraphPatternOperation::BasicGraphPattern{});
     }
+    ad_utility::appendVector(
+        get<GraphPatternOperation::BasicGraphPattern>(ops.back().variant_)
+            ._whereClauseTriples,
+        std::move(triples.value()._whereClauseTriples));
   }
-  return {ops, filters};
+  return {std::move(ops), std::move(filters)};
 }
 
-// TODO: Package this type into a struct.
-std::pair<variant<GraphPatternOperation, SparqlFilter>,
-          std::optional<GraphPatternOperation::BasicGraphPattern>>
-Visitor::visitTypesafe(
+Visitor::OperationOrFilterAndMaybeTriples Visitor::visitTypesafe(
     Parser::GraphPatternNotTriplesAndMaybeTriplesContext* ctx) {
-  auto triples = ctx->triplesBlock()
-                     ? std::optional{GraphPatternOperation::BasicGraphPattern{
-                           visitTypesafe(ctx->triplesBlock())}}
-                     : std::nullopt;
-  return {visitTypesafe(ctx->graphPatternNotTriples()), std::move(triples)};
+  return {visitTypesafe(ctx->graphPatternNotTriples()),
+          visitOptional(ctx->triplesBlock())};
 }
 
 // ____________________________________________________________________________________
-vector<SparqlTriple> Visitor::visitTypesafe(Parser::TriplesBlockContext* ctx) {
+GraphPatternOperation::BasicGraphPattern Visitor::visitTypesafe(
+    Parser::TriplesBlockContext* ctx) {
   auto iri = [](const Iri& iri) -> TripleComponent { return iri.toSparql(); };
   auto blankNode = [](const BlankNode& blankNode) -> TripleComponent {
     return blankNode.toSparql();
@@ -325,7 +324,7 @@ vector<SparqlTriple> Visitor::visitTypesafe(Parser::TriplesBlockContext* ctx) {
 
   auto registerIfVariable = [this](auto& variant) {
     if (holds_alternative<Variable>(variant)) {
-      visibleVariables_.back().emplace_back(std::get<Variable>(variant));
+      addVisibleVariable(std::get<Variable>(variant));
     }
   };
 
@@ -344,13 +343,14 @@ vector<SparqlTriple> Visitor::visitTypesafe(Parser::TriplesBlockContext* ctx) {
   auto triples = ad_utility::transform(
       visitTypesafe(ctx->triplesSameSubjectPath()), convertAndRegisterTriple);
   if (ctx->triplesBlock()) {
-    ad_utility::appendVector(triples, visitTypesafe(ctx->triplesBlock()));
+    ad_utility::appendVector(
+        triples, visitTypesafe(ctx->triplesBlock())._whereClauseTriples);
   }
-  return triples;
+  return {triples};
 }
 
 // ____________________________________________________________________________________
-std::variant<GraphPatternOperation, SparqlFilter> Visitor::visitTypesafe(
+Visitor::OperationOrFilter Visitor::visitTypesafe(
     Parser::GraphPatternNotTriplesContext* ctx) {
   if (ctx->graphGraphPattern() || ctx->serviceGraphPattern()) {
     reportError(ctx,
@@ -367,7 +367,8 @@ GraphPatternOperation Visitor::visitTypesafe(
     Parser::OptionalGraphPatternContext* ctx) {
   auto pattern = visitTypesafe(ctx->groupGraphPattern());
   pattern._optional = true;
-  return GraphPatternOperation{GraphPatternOperation::Optional{pattern}};
+  return GraphPatternOperation{
+      GraphPatternOperation::Optional{std::move(pattern)}};
 }
 
 // ____________________________________________________________________________________
@@ -566,7 +567,9 @@ GraphPatternOperation::Subquery Visitor::visitTypesafe(
   numInternalVariables_ = query.getNumInternalVariables();
   if (ctx->valuesClause() && !ctx->valuesClause()->getText().empty()) {
     // TODO: implement
-    reportError(ctx->valuesClause(), "ValuesClause is not yet implemented.");
+    reportError(
+        ctx->valuesClause(),
+        "VALUES clause directly after a Subquery is not yet implemented.");
   }
   // auto values = visitTypesafe(ctx->valuesClause());
   // if (values.has_value()) {
@@ -578,7 +581,7 @@ GraphPatternOperation::Subquery Visitor::visitTypesafe(
   }
   // Variables that are selected in this query are visible in the parent query.
   for (const auto& variable : query.selectClause().getSelectedVariables()) {
-    visibleVariables_.back().emplace_back(variable);
+    addVisibleVariable(variable);
   }
   query._numGraphPatterns = numGraphPatterns_++;
   return {std::move(query)};

src/parser/sparqlParser/SparqlQleverVisitor.h

@@ -3,27 +3,26 @@
 
 #pragma once
 
-#include "../../engine/sparqlExpressions/AggregateExpression.h"
-#include "../../engine/sparqlExpressions/GroupConcatExpression.h"
-#include "../../engine/sparqlExpressions/LiteralExpression.h"
-#include "../../engine/sparqlExpressions/NaryExpression.h"
-#include "../../engine/sparqlExpressions/SparqlExpressionPimpl.h"
-// #include "../../engine/sparqlExpressions/RelationalExpression.h"
-#include "../../engine/sparqlExpressions/SampleExpression.h"
-#include "../../util/HashMap.h"
-#include "../../util/OverloadCallOperator.h"
-#include "../../util/StringUtils.h"
-#include "../../util/antlr/ANTLRErrorHandling.h"
-#include "../Alias.h"
-#include "../ParsedQuery.h"
-#include "../RdfEscaping.h"
-#include "../data/BlankNode.h"
-#include "../data/Iri.h"
-#include "../data/SolutionModifiers.h"
-#include "../data/Types.h"
-#include "../data/VarOrTerm.h"
-#include "antlr4-runtime.h"
-#include "generated/SparqlAutomaticVisitor.h"
+#include <antlr4-runtime.h>
+#include <engine/sparqlExpressions/AggregateExpression.h>
+#include <engine/sparqlExpressions/GroupConcatExpression.h>
+#include <engine/sparqlExpressions/LiteralExpression.h>
+#include <engine/sparqlExpressions/NaryExpression.h>
+#include <engine/sparqlExpressions/SampleExpression.h>
+#include <engine/sparqlExpressions/SparqlExpressionPimpl.h>
+#include <parser/Alias.h>
+#include <parser/ParsedQuery.h>
+#include <parser/RdfEscaping.h>
+#include <parser/data/BlankNode.h>
+#include <parser/data/Iri.h>
+#include <parser/data/SolutionModifiers.h>
+#include <parser/data/Types.h>
+#include <parser/data/VarOrTerm.h>
+#include <parser/sparqlParser/generated/SparqlAutomaticVisitor.h>
+#include <util/HashMap.h>
+#include <util/OverloadCallOperator.h>
+#include <util/StringUtils.h>
+#include <util/antlr/ANTLRErrorHandling.h>
 
 template <typename T>
 class Reversed {
@@ -54,6 +53,12 @@ class SparqlQleverVisitor : public SparqlAutomaticVisitor {
   using ObjectList = ad_utility::sparql_types::ObjectList;
   using PropertyList = ad_utility::sparql_types::PropertyList;
   using Any = antlrcpp::Any;
+  using OperationsAndFilters =
+      std::pair<vector<GraphPatternOperation>, vector<SparqlFilter>>;
+  using OperationOrFilterAndMaybeTriples =
+      std::pair<variant<GraphPatternOperation, SparqlFilter>,
+                std::optional<GraphPatternOperation::BasicGraphPattern>>;
+  using OperationOrFilter = std::variant<GraphPatternOperation, SparqlFilter>;
   size_t _blankNodeCounter = 0;
   int64_t numInternalVariables_ = 0;
   int64_t numGraphPatterns_ = 0;
@@ -101,6 +106,11 @@ class SparqlQleverVisitor : public SparqlAutomaticVisitor {
   ExpressionPtr processIriFunctionCall(const std::string& iri,
                                        std::vector<ExpressionPtr> argList);
 
+  // TODO: Remove addVisibleVariable(const string&) when all Types use the
+  //  strong type Variable.
+  void addVisibleVariable(const string& var);
+  void addVisibleVariable(const Variable& var);
+
  public:
   // ___________________________________________________________________________
   Any visitQuery(Parser::QueryContext* ctx) override {
@@ -297,23 +307,22 @@ class SparqlQleverVisitor : public SparqlAutomaticVisitor {
     return visitTypesafe(ctx);
   }
 
-  std::pair<vector<GraphPatternOperation>, vector<SparqlFilter>> visitTypesafe(
-      Parser::GroupGraphPatternSubContext* ctx);
+  OperationsAndFilters visitTypesafe(Parser::GroupGraphPatternSubContext* ctx);
 
   Any visitGraphPatternNotTriplesAndMaybeTriples(
       Parser::GraphPatternNotTriplesAndMaybeTriplesContext* ctx) override {
     return visitTypesafe(ctx);
   }
 
-  std::pair<variant<GraphPatternOperation, SparqlFilter>,
-            std::optional<GraphPatternOperation::BasicGraphPattern>>
-  visitTypesafe(Parser::GraphPatternNotTriplesAndMaybeTriplesContext* ctx);
+  OperationOrFilterAndMaybeTriples visitTypesafe(
+      Parser::GraphPatternNotTriplesAndMaybeTriplesContext* ctx);
 
   Any visitTriplesBlock(Parser::TriplesBlockContext* ctx) override {
     return visitTypesafe(ctx);
   }
 
-  vector<SparqlTriple> visitTypesafe(Parser::TriplesBlockContext* ctx);
+  GraphPatternOperation::BasicGraphPattern visitTypesafe(
+      Parser::TriplesBlockContext* ctx);
 
   Any visitGraphPatternNotTriples(
       Parser::GraphPatternNotTriplesContext* ctx) override {
@@ -322,8 +331,7 @@ class SparqlQleverVisitor : public SparqlAutomaticVisitor {
 
   // Filter clauses are no independent graph patterns themselves, but their
   // scope is always the complete graph pattern enclosing them.
-  std::variant<GraphPatternOperation, SparqlFilter> visitTypesafe(
-      Parser::GraphPatternNotTriplesContext* ctx);
+  OperationOrFilter visitTypesafe(Parser::GraphPatternNotTriplesContext* ctx);
 
   Any visitOptionalGraphPattern(
       Parser::OptionalGraphPatternContext* ctx) override {

src/parser/sparqlParser/generated/SparqlAutomatic.g4

@@ -160,6 +160,7 @@ groupGraphPatternSub
     : triplesBlock? graphPatternNotTriplesAndMaybeTriples*
     ;
 
+/* Helper rules to make parsing of groupGraphPatternSub easier. */
 graphPatternNotTriplesAndMaybeTriples
     : graphPatternNotTriples '.'? triplesBlock?
     ;

src/util/Algorithm.h

@@ -5,6 +5,11 @@
 #ifndef QLEVER_ALGORITHM_H
 #define QLEVER_ALGORITHM_H
 
+#include <util/TypeTraits.h>
+
+#include <utility>
+
+// TODO: Test the algorithms.
 namespace ad_utility {
 
 /**
@@ -39,10 +44,15 @@ bool contains_if(const Container& container, const Predicate& predicate) {
  * @param destination Vector& to which to append
  * @param source Vector&& to append
  */
-template <typename T>
-void appendVector(std::vector<T>& destination, std::vector<T>&& source) {
-  destination.insert(destination.end(), std::make_move_iterator(source.begin()),
-                     std::make_move_iterator(source.end()));
+template <typename T, ad_utility::SimilarTo<std::vector<T>> U>
+void appendVector(std::vector<T>& destination, U&& source) {
+  if constexpr (std::is_rvalue_reference_v<U&&>) {
+    destination.insert(destination.end(),
+                       std::make_move_iterator(source.begin()),
+                       std::make_move_iterator(source.end()));
+  } else {
+    destination.insert(destination.end(), source.begin(), source.end());
+  }
 }
 
 /**