Parse update queries

src/parser/Triples.h → src/parser/SparqlTriple.h

@@ -1,6 +1,7 @@
 //  Copyright 2024, University of Freiburg,
 //  Chair of Algorithms and Data Structures.
-//  Author: Julian Mundhahs ([email protected])
+//  Authors: Björn Buchhold ([email protected])
+//           Johannes Kalmbach <[email protected]>
 
 #pragma once
 

src/parser/UpdateClause.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "parser/SelectClause.h"
-#include "parser/Triples.h"
+#include "parser/SparqlTriple.h"
 #include "parser/data/Types.h"
 
 namespace parsedQuery {
@@ -14,8 +14,8 @@
   std::vector<SparqlTripleSimple> toDelete_;
 
   UpdateClause() = default;
-  explicit UpdateClause(std::vector<SparqlTripleSimple> toInsert,
-                        std::vector<SparqlTripleSimple> toDelete)
+  UpdateClause(std::vector<SparqlTripleSimple> toInsert,
+               std::vector<SparqlTripleSimple> toDelete)
       : toInsert_{std::move(toInsert)}, toDelete_{std::move(toDelete)} {}
 };
 }  // namespace parsedQuery

src/parser/sparqlParser/SparqlQleverVisitor.cpp

@@ -330,9 +330,8 @@
   visit(ctx->prologue());
 
   if (ctx->update()) {
-    reportNotSupported(ctx->update(),
-                       "Multiple updates in one query are not supported.");
+    reportNotSupported(ctx->update(), "Multiple updates in one query are");
   }
   return visit(ctx->update1());
 }
 
@@ -342,56 +341,64 @@
     return visit(ctx->modify());
   }
 
+  // TODO: updates can be chained; think about how to enable this
+
   parsedQuery_._clause = parsedQuery::UpdateClause();
 
   if (ctx->insertData()) {
     parsedQuery_.updateClause().toInsert_ = visit(ctx->insertData());
   } else if (ctx->deleteData()) {
     parsedQuery_.updateClause().toDelete_ = visit(ctx->deleteData());
+  } else if (ctx->deleteWhere()) {
+    auto [toDelete, pattern] = visit(ctx->deleteWhere());
+    parsedQuery_.updateClause().toDelete_ = std::move(toDelete);
+    parsedQuery_._rootGraphPattern = std::move(pattern);
+  } else if (ctx->modify()) {
+    // updates the internal state of `parsedQuery_`
+    visit(ctx->modify());
   } else {
     visitAlternative<void>(ctx->load(), ctx->clear(), ctx->drop(), ctx->add(),
-                           ctx->move(), ctx->copy(), ctx->create(),
-                           ctx->deleteWhere());
+                           ctx->move(), ctx->copy(), ctx->create());
     AD_FAIL();
   }
 
   return parsedQuery_;
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::LoadContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Load is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Load is");
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::ClearContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Clear is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Clear is");
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::DropContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Drop is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Drop is");
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::CreateContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Create is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Create is");
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::AddContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Add is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Add is");
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::MoveContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Move is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Move is");
 }
 
 // ____________________________________________________________________________________
 void Visitor::visit(Parser::CopyContext* ctx) {
-  reportNotSupported(ctx, "SPARQL 1.1 Update Copy is not supported.");
+  reportNotSupported(ctx, "SPARQL 1.1 Update Copy is");
 }
 
 // ____________________________________________________________________________________
 vector<SparqlTripleSimple> Visitor::visit(Parser::InsertDataContext* ctx) {
@@ -404,23 +411,40 @@
 }
 
 // ____________________________________________________________________________________
-void Visitor::visit(Parser::DeleteWhereContext* ctx) {
-  // DeleteData only deletes the specified triples. DeleteWhere matches the
-  // given pattern and then deletes the matched triples. This is a shortcut for
-  // a modify query.
-  reportNotSupported(ctx, "SPARQL 1.1 Update DeleteWhere is not supported.");
+std::pair<vector<SparqlTripleSimple>, ParsedQuery::GraphPattern> Visitor::visit(
+    Parser::DeleteWhereContext* ctx) {
+  auto triples = visit(ctx->quadPattern());
+  auto transformTriple =
+      [&ctx](const SparqlTripleSimple& triple) -> SparqlTriple {
+    if (triple.p_.isVariable()) {
+      return {triple.s_, PropertyPath::fromVariable(triple.p_.getVariable()),
+              triple.o_};
+    } else if (triple.p_.isIri()) {
+      return {
+          triple.s_,
+          PropertyPath::fromIri(triple.p_.getIri().toStringRepresentation()),
+          triple.o_};
+    } else {
+      reportError(ctx, "Predicate must a PropertyPath");
+    }
+  };
+  GraphPattern pattern;
+  pattern._graphPatterns.emplace_back(
+      BasicGraphPattern{ad_utility::transform(triples, transformTriple)});
+
+  return {std::move(triples), std::move(pattern)};
 }
 
 // ____________________________________________________________________________________
 ParsedQuery Visitor::visit(Parser::ModifyContext* ctx) {
   if (ctx->iri()) {
     // Could also be default; disallow completely for now.
-    reportNotSupported(ctx->iri(), "Named graphs are not supported.");
+    reportNotSupported(ctx->iri(), "Named graphs are");
   }
   if (!ctx->usingClause().empty()) {
     reportNotSupported(ctx->usingClause(0),
-                       "Using is not supported in Update/Insert.");
+                       "USING inside an DELETE or INSERT is");
   }
 
   parsedQuery_._rootGraphPattern = visit(ctx->groupGraphPattern());
 
@@ -455,9 +479,9 @@
   auto quads = visit(ctx->quads());
   auto checkAndReportVar = [&ctx](const TripleComponent& term) {
     if (term.isVariable()) {
       reportError(ctx->quads(), "Variables (" + term.getVariable().name() +
                                     ") are not allowed here.");
     }
   };
 
   for (const auto& quad : quads) {
@@ -473,14 +497,14 @@
 vector<SparqlTripleSimple> Visitor::visit(Parser::QuadsContext* ctx) {
   if (!ctx->quadsNotTriples().empty()) {
     // Could also be default; disallow completely for now.
-    reportNotSupported(ctx->quadsNotTriples(0),
-                       "Named graphs are not supported.");
+    reportNotSupported(ctx->quadsNotTriples(0), "Named graphs are");
   }
 
   AD_CORRECTNESS_CHECK(ctx->triplesTemplate().size() == 1);
 
   auto convertAndRegisterTriple =
       [this](const std::array<GraphTerm, 3>& triple) -> SparqlTripleSimple {
+    // TODO:
     registerIfVariable(triple[0]);
     registerIfVariable(triple[1]);
     registerIfVariable(triple[2]);
@@ -489,9 +513,8 @@
             visitGraphTerm(triple[2])};
   };
 
-  std::vector<SparqlTripleSimple> triples = {ad_utility::transform(
-      visit(ctx->triplesTemplate(0)), convertAndRegisterTriple)};
-  return triples;
+  return ad_utility::transform(visit(ctx->triplesTemplate(0)),
+                               convertAndRegisterTriple);
 }
 
 // ____________________________________________________________________________________
@@ -2328,11 +2351,11 @@
     if constexpr (std::is_same_v<T, Variable>) {
       return element;
     } else if constexpr (std::is_same_v<T, Literal> || std::is_same_v<T, Iri>) {
       return TurtleStringParser<TokenizerCtre>::parseTripleObject(
           element.toSparql());
     } else {
       return element.toSparql();
     }
   });
 }
 

src/parser/sparqlParser/SparqlQleverVisitor.h

@@ -221,7 +221,8 @@ class SparqlQleverVisitor {
 
   vector<SparqlTripleSimple> visit(Parser::DeleteDataContext* ctx);
 
-  void visit(Parser::DeleteWhereContext* ctx);
+  std::pair<vector<SparqlTripleSimple>, ParsedQuery::GraphPattern> visit(
+      Parser::DeleteWhereContext* ctx);
 
   ParsedQuery visit(Parser::ModifyContext* ctx);
 
@@ -625,6 +626,9 @@ class SparqlQleverVisitor {
   void setMatchingWordAndScoreVisibleIfPresent(
       auto* ctx, const TripleWithPropertyPath& triple);
 
+  // Constructs a TripleComponent from a GraphTerm.
   static TripleComponent visitGraphTerm(const GraphTerm& graphTerm);
+  // If argument is a variant that contains a Variable register that Variable as
+  // visible in the current scope.
   void registerIfVariable(const auto& variant);
 };

test/SparqlAntlrParserTest.cpp

@@ -1666,8 +1666,8 @@ TEST(SparqlParser, UpdateQuery) {
                m::UpdateQuery({}, {{Iri("<a>"), Iri("<b>"), Iri("<c>")}},
                               m::GraphPattern()));
   expectUpdate(
-      "INSERT DATA { \"foo:bar\" <b> <c> }",
-      m::UpdateQuery({}, {{Literal("\"foo:bar\""), Iri("<b>"), Iri("<c>")}},
+      "INSERT DATA { <a> <b> \"foo:bar\" }",
+      m::UpdateQuery({}, {{Iri("<a>"), Iri("<b>"), Literal("\"foo:bar\"")}},
                      m::GraphPattern()));
   expectUpdate("DELETE DATA { <a> <b> <c> }",
                m::UpdateQuery({{Iri("<a>"), Iri("<b>"), Iri("<c>")}}, {},

test/SparqlAntlrParserTestHelpers.h

@@ -824,9 +824,9 @@ inline auto ConstructQuery(const std::vector<std::array<GraphTerm, 3>>& elems,
     -> Matcher<const ParsedQuery&> {
   return testing::AllOf(
       AD_PROPERTY(ParsedQuery, hasConstructClause, testing::IsTrue()),
-      AD_PROPERTY(
-          ParsedQuery, constructClause,
-          AD_FIELD(parsedQuery::ConstructClause, triples_, testing::Eq(elems))),
+      AD_PROPERTY(ParsedQuery, constructClause,
+                  AD_FIELD(parsedQuery::ConstructClause, triples_,
+                           testing::ElementsAreArray(elems))),
       RootGraphPattern(m));
 }
 
@@ -845,10 +845,10 @@ inline auto UpdateQuery =
       AD_PROPERTY(ParsedQuery, hasUpdateClause, testing::IsTrue()),
       AD_PROPERTY(ParsedQuery, updateClause,
                   AD_FIELD(parsedQuery::UpdateClause, toDelete_,
-                           testing::Eq(toDelete))),
+                           testing::ElementsAreArray(toDelete))),
       AD_PROPERTY(ParsedQuery, updateClause,
                   AD_FIELD(parsedQuery::UpdateClause, toInsert_,
-                           testing::Eq(toInsert))),
+                           testing::ElementsAreArray(toInsert))),
       RootGraphPattern(graphPatternMatcher));
 };