[SPARQL 1.1 Update] - Parser and AST : INSERT/DELETE

src/main/java/fr/inria/corese/core/next/query/impl/parser/SparqlListenerDispatcher.java

@@ -342,4 +342,34 @@ public void enterMove(SparqlParser.MoveContext ctx) {
     public void exitMove(SparqlParser.MoveContext ctx) {
         for (var d : delegates) d.exitMove(ctx);
     }
+
+    @Override
+    public void enterInsertData(SparqlParser.InsertDataContext ctx) {
+        for (var d : delegates) d.enterInsertData(ctx);
+    }
+
+    @Override
+    public void exitInsertData(SparqlParser.InsertDataContext ctx) {
+        for (var d : delegates) d.exitInsertData(ctx);
+    }
+
+    @Override
+    public void enterDeleteData(SparqlParser.DeleteDataContext ctx) {
+        for (var d : delegates) d.enterDeleteData(ctx);
+    }
+
+    @Override
+    public void exitDeleteData(SparqlParser.DeleteDataContext ctx) {
+        for (var d : delegates) d.exitDeleteData(ctx);
+    }
+
+    @Override
+    public void enterDeleteWhere(SparqlParser.DeleteWhereContext ctx) {
+        for (var d : delegates) d.enterDeleteWhere(ctx);
+    }
+
+    @Override
+    public void exitDeleteWhere(SparqlParser.DeleteWhereContext ctx) {
+        for (var d : delegates) d.exitDeleteWhere(ctx);
+    }
 }

src/main/java/fr/inria/corese/core/next/query/impl/parser/SparqlQueryAnalyzer.java

@@ -165,6 +165,9 @@ private QueryAst buildAst(
                     new AddUpdateAstListener(updateBuilder),
                     new CopyUpdateAstListener(updateBuilder),
                     new MoveUpdateAstListener(updateBuilder),
+                    new InsertDataUpdateAstListener(updateBuilder),
+                    new DeleteDataUpdateAstListener(updateBuilder),
+                    new DeleteWhereUpdateAstListener(updateBuilder),
                     new BgpAstListener(updateBuilder),
                     new BindAstListener(updateBuilder),
                     new FilterAstListener(updateBuilder),

src/main/java/fr/inria/corese/core/next/query/impl/parser/SparqlUpdateAstBuilder.java

@@ -104,4 +104,57 @@ public MoveRequestAst moveToAst(SparqlParser.MoveContext ctx) {
                 graphRefFromGraphOrDefault(ctx.graphOrDefault(1)),
                 ctx.SILENT() != null);
     }
+
+    public InsertDataRequestAst insertDataToAst(SparqlParser.InsertDataContext ctx) {
+        return new InsertDataRequestAst(quadsFromQuads(ctx.quadData().quads()));
+    }
+
+    public DeleteDataRequestAst deleteDataToAst(SparqlParser.DeleteDataContext ctx) {
+        return new DeleteDataRequestAst(quadsFromQuads(ctx.quadData().quads()));
+    }
+
+    public DeleteWhereRequestAst deleteWhereToAst(SparqlParser.DeleteWhereContext ctx) {
+        return new DeleteWhereRequestAst(quadsFromQuads(ctx.quadPattern().quads()));
+    }
+
+    private QuadsAst quadsFromQuads(SparqlParser.QuadsContext ctx) {
+        List<TriplePatternAst> defaultTriples = new ArrayList<>();
+        List<NamedGraphQuadsAst> namedGraphBlocks = new ArrayList<>();
+
+        for (SparqlParser.TriplesTemplateContext tt : ctx.triplesTemplate()) {
+            defaultTriples.addAll(triplesFromTriplesTemplate(tt));
+        }
+
+        for (SparqlParser.QuadsNotTriplesContext qnt : ctx.quadsNotTriples()) {
+            TermAst graph = termFromVarOrIriRef(qnt.varOrIri());
+            List<TriplePatternAst> graphTriples = new ArrayList<>();
+            if (qnt.triplesTemplate() != null) {
+                graphTriples.addAll(triplesFromTriplesTemplate(qnt.triplesTemplate()));
+            }
+            namedGraphBlocks.add(new NamedGraphQuadsAst(graph, graphTriples));
+        }
+
+        return new QuadsAst(defaultTriples, namedGraphBlocks);
+    }
+
+    private List<TriplePatternAst> triplesFromTriplesTemplate(SparqlParser.TriplesTemplateContext ctx) {
+        List<TriplePatternAst> triples = new ArrayList<>();
+        SparqlParser.TriplesTemplateContext current = ctx;
+        while (current != null) {
+            SparqlParser.TriplesSameSubjectContext tss = current.triplesSameSubject();
+            if (tss != null && tss.varOrTerm() != null && tss.propertyListNotEmpty() != null) {
+                TermAst subject = termFromVarOrTerm(tss.varOrTerm());
+                var propertyList = tss.propertyListNotEmpty();
+                for (int verbIndex = 0; verbIndex < propertyList.verb().size(); verbIndex++) {
+                    TermAst predicate = termFromVerb(propertyList.verb(verbIndex));
+                    List<TermAst> objects = termListFromObjectList(propertyList.objectList(verbIndex));
+                    for (TermAst object : objects) {
+                        triples.add(new TriplePatternAst(subject, predicate, object));
+                    }
+                }
+            }
+            current = current.triplesTemplate();
+        }
+        return triples;
+    }
 }

src/main/java/fr/inria/corese/core/next/query/impl/parser/listener/BgpAstListener.java

@@ -67,6 +67,9 @@ public void exitTriplesSameSubject(SparqlParser.TriplesSameSubjectContext ctx) {
         if (ctx.getParent() instanceof SparqlParser.ConstructTriplesContext) {
             return;
         }
+        if (ctx.getParent() instanceof SparqlParser.TriplesTemplateContext) {
+            return;
+        }
         if (ctx.varOrTerm() == null || ctx.propertyListNotEmpty() == null) {
             return;
         }

src/main/java/fr/inria/corese/core/next/query/impl/parser/listener/DeleteDataUpdateAstListener.java

@@ -0,0 +1,20 @@
+package fr.inria.corese.core.next.query.impl.parser.listener;
+
+import fr.inria.corese.core.next.impl.parser.antlr.SparqlParser;
+import fr.inria.corese.core.next.query.impl.parser.SparqlUpdateAstBuilder;
+import fr.inria.corese.core.next.query.impl.sparql.ast.DeleteDataRequestAst;
+
+/**
+ * AST feature listener for DELETE DATA SPARQL update query.
+ */
+public class DeleteDataUpdateAstListener extends AbstractSparqlUpdateAstListener {
+    public DeleteDataUpdateAstListener(SparqlUpdateAstBuilder builder) {
+        super(builder);
+    }
+
+    @Override
+    public void exitDeleteData(SparqlParser.DeleteDataContext ctx) {
+        DeleteDataRequestAst ast = this.updateBuilder().deleteDataToAst(ctx);
+        this.updateBuilder().addRequest(ast);
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/parser/listener/DeleteWhereUpdateAstListener.java

@@ -0,0 +1,20 @@
+package fr.inria.corese.core.next.query.impl.parser.listener;
+
+import fr.inria.corese.core.next.impl.parser.antlr.SparqlParser;
+import fr.inria.corese.core.next.query.impl.parser.SparqlUpdateAstBuilder;
+import fr.inria.corese.core.next.query.impl.sparql.ast.DeleteWhereRequestAst;
+
+/**
+ * AST feature listener for DELETE WHERE SPARQL update query.
+ */
+public class DeleteWhereUpdateAstListener extends AbstractSparqlUpdateAstListener {
+    public DeleteWhereUpdateAstListener(SparqlUpdateAstBuilder builder) {
+        super(builder);
+    }
+
+    @Override
+    public void exitDeleteWhere(SparqlParser.DeleteWhereContext ctx) {
+        DeleteWhereRequestAst ast = this.updateBuilder().deleteWhereToAst(ctx);
+        this.updateBuilder().addRequest(ast);
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/parser/listener/InsertDataUpdateAstListener.java

@@ -0,0 +1,20 @@
+package fr.inria.corese.core.next.query.impl.parser.listener;
+
+import fr.inria.corese.core.next.impl.parser.antlr.SparqlParser;
+import fr.inria.corese.core.next.query.impl.parser.SparqlUpdateAstBuilder;
+import fr.inria.corese.core.next.query.impl.sparql.ast.InsertDataRequestAst;
+
+/**
+ * AST feature listener for INSERT DATA SPARQL update query.
+ */
+public class InsertDataUpdateAstListener extends AbstractSparqlUpdateAstListener {
+    public InsertDataUpdateAstListener(SparqlUpdateAstBuilder builder) {
+        super(builder);
+    }
+
+    @Override
+    public void exitInsertData(SparqlParser.InsertDataContext ctx) {
+        InsertDataRequestAst ast = this.updateBuilder().insertDataToAst(ctx);
+        this.updateBuilder().addRequest(ast);
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/parser/semantic/support/AbstractAstVisitor.java

@@ -107,4 +107,14 @@ public void visit(GraphRefAst ast) {
     public void visit(PathAst ast) {
 
     }
+
+    @Override
+    public void visit(QuadsAst ast) {
+
+    }
+
+    @Override
+    public void visit(NamedGraphQuadsAst ast) {
+
+    }
 }

src/main/java/fr/inria/corese/core/next/query/impl/parser/semantic/support/AstVisitor.java

@@ -27,4 +27,6 @@ public interface AstVisitor {
     void visit(ServiceAst ast);
     void visit(GraphRefAst ast);
     void visit(PathAst ast);
+    void visit(QuadsAst ast);
+    void visit(NamedGraphQuadsAst ast);
 }

src/main/java/fr/inria/corese/core/next/query/impl/sparql/ast/DeleteDataRequestAst.java

@@ -0,0 +1,21 @@
+package fr.inria.corese.core.next.query.impl.sparql.ast;
+
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.AstVisitor;
+
+/**
+ * Represents the {@code DELETE DATA} operation as defined in the
+ * <a href="https://www.w3.org/TR/2013/REC-sparql11-update-20130321/#deleteData">SPARQL 1.1 recommendation</a>.
+ *
+ * @param data the quad data to delete (ground triples only — no variables)
+ */
+public record DeleteDataRequestAst(QuadsAst data) implements UpdateRequestUnitAst {
+    public DeleteDataRequestAst {
+        if (data == null) throw new IllegalArgumentException("data must be non-null");
+    }
+
+    @Override
+    public void accept(AstVisitor visitor) {
+        visitor.visit(this);
+        data.accept(visitor);
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/sparql/ast/DeleteWhereRequestAst.java

@@ -0,0 +1,23 @@
+package fr.inria.corese.core.next.query.impl.sparql.ast;
+
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.AstVisitor;
+
+/**
+ * Represents the {@code DELETE WHERE} operation as defined in the
+ * <a href="https://www.w3.org/TR/2013/REC-sparql11-update-20130321/#deleteWhere">SPARQL 1.1 recommendation</a>.
+ *
+ * <p>The quad pattern is used both as the pattern to match and as the template of triples to delete.
+ *
+ * @param pattern the quad pattern (may contain variables)
+ */
+public record DeleteWhereRequestAst(QuadsAst pattern) implements UpdateRequestUnitAst {
+    public DeleteWhereRequestAst {
+        if (pattern == null) throw new IllegalArgumentException("pattern must be non-null");
+    }
+
+    @Override
+    public void accept(AstVisitor visitor) {
+        visitor.visit(this);
+        pattern.accept(visitor);
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/sparql/ast/InsertDataRequestAst.java

@@ -0,0 +1,21 @@
+package fr.inria.corese.core.next.query.impl.sparql.ast;
+
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.AstVisitor;
+
+/**
+ * Represents the {@code INSERT DATA} operation as defined in the
+ * <a href="https://www.w3.org/TR/2013/REC-sparql11-update-20130321/#insertData">SPARQL 1.1 recommendation</a>.
+ *
+ * @param data the quad data to insert (ground triples only — no variables)
+ */
+public record InsertDataRequestAst(QuadsAst data) implements UpdateRequestUnitAst {
+    public InsertDataRequestAst {
+        if (data == null) throw new IllegalArgumentException("data must be non-null");
+    }
+
+    @Override
+    public void accept(AstVisitor visitor) {
+        visitor.visit(this);
+        data.accept(visitor);
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/sparql/ast/NamedGraphQuadsAst.java

@@ -0,0 +1,26 @@
+package fr.inria.corese.core.next.query.impl.sparql.ast;
+
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.AstVisitor;
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.VisitableAst;
+
+import java.util.List;
+
+/**
+ * A {@code GRAPH varOrIri { triplesTemplate? }} block inside a {@code quads} body.
+ *
+ * @param graph   the named graph IRI or variable
+ * @param triples the triple patterns inside the named graph block
+ */
+public record NamedGraphQuadsAst(TermAst graph, List<TriplePatternAst> triples) implements VisitableAst {
+    public NamedGraphQuadsAst {
+        if (graph == null) throw new IllegalArgumentException("graph must be non-null");
+        triples = triples != null ? List.copyOf(triples) : List.of();
+    }
+
+    @Override
+    public void accept(AstVisitor visitor) {
+        visitor.visit(this);
+        graph.accept(visitor);
+        triples.forEach(t -> t.accept(visitor));
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/sparql/ast/QuadsAst.java

@@ -0,0 +1,28 @@
+package fr.inria.corese.core.next.query.impl.sparql.ast;
+
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.AstVisitor;
+import fr.inria.corese.core.next.query.impl.parser.semantic.support.VisitableAst;
+
+import java.util.List;
+
+/**
+ * Represents the body of a {@code quadData} or {@code quadPattern} block as defined in
+ * <a href="https://www.w3.org/TR/sparql11-update/">SPARQL 1.1 Update</a>.
+ *
+ * @param defaultTriples   triple patterns targeting the default graph
+ * @param namedGraphBlocks named-graph triple blocks
+ */
+public record QuadsAst(List<TriplePatternAst> defaultTriples, List<NamedGraphQuadsAst> namedGraphBlocks)
+        implements VisitableAst {
+    public QuadsAst {
+        defaultTriples = defaultTriples != null ? List.copyOf(defaultTriples) : List.of();
+        namedGraphBlocks = namedGraphBlocks != null ? List.copyOf(namedGraphBlocks) : List.of();
+    }
+
+    @Override
+    public void accept(AstVisitor visitor) {
+        visitor.visit(this);
+        defaultTriples.forEach(t -> t.accept(visitor));
+        namedGraphBlocks.forEach(b -> b.accept(visitor));
+    }
+}

src/main/java/fr/inria/corese/core/next/query/impl/sparql/ast/UpdateRequestUnitAst.java

@@ -5,5 +5,5 @@
 /**
  * Root interface for all operations related to the SPARQL Update operations listed in <a href="https://www.w3.org/TR/sparql11-update/">SPARQL 1.1 Update</a>.
  */
-public sealed interface UpdateRequestUnitAst extends VisitableAst permits LoadRequestAst, ClearRequestAst, CreateRequestAst, DropRequestAst, AddRequestAst, CopyRequestAst, MoveRequestAst {
+public sealed interface UpdateRequestUnitAst extends VisitableAst permits LoadRequestAst, ClearRequestAst, CreateRequestAst, DropRequestAst, AddRequestAst, CopyRequestAst, MoveRequestAst, InsertDataRequestAst, DeleteDataRequestAst, DeleteWhereRequestAst {
 }