Skip to content

Feature/335 property path parser and ast #463

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
prbblrypier wants to merge 13 commits into
base: feature/corese-next
Choose a base branch
from
Open

Feature/335 property path parser and ast #463

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
13 commits
Select commit Hold shift + click to select a range
0393d75
path ast
prbblrypier Jun 2, 2026
853e7ff
fix(next/parser): TriplePatternAst PathAst predicate + addTriple over…
prbblrypier Jun 16, 2026
79a2445
feat(next/parser): map SPARQL property paths to PathAst in SparqlAstB…
prbblrypier Jun 16, 2026
236d095
path ast parser
prbblrypier Jun 17, 2026
006c8e0
ast visitor after rebase
MaillPierre Jun 22, 2026
67913bb
bump gradle 9.1
prbblrypier Jun 17, 2026
ff3bd02
path ast
prbblrypier Jun 2, 2026
9fce9e0
fix(next/parser): TriplePatternAst PathAst predicate + addTriple over…
prbblrypier Jun 16, 2026
9c9e450
path ast parser
prbblrypier Jun 17, 2026
4639eff
bump gradle 9.1
prbblrypier Jul 8, 2026
e1a7107
fix(next/bridge): support simple PathAst predicates
prbblrypier Jul 8, 2026
3f682b7
avoid generated blank node label collisions
prbblrypier Jul 8, 2026
407fae3
test: strengthen property path AST coverage
remiceres Jul 10, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion build.gradle.kts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -308,7 +308,7 @@ tasks.named("compileJava") {

// Ensure sources JAR includes generated sources and depends on code generation
tasks.named<Jar>("sourcesJar") {
dependsOn("generateGrammarSource", "javaccSparqlCorese")
dependsOn("generateGrammarSource", "generateTestGrammarSource", "javaccSparqlCorese")
from(javaccGeneratedDir)
from(antlrPackageDir)
includeEmptyDirs = false
Expand Down
271 changes: 251 additions & 20 deletions src/main/java/fr/inria/corese/core/next/query/impl/parser/SparqlAstBuilder.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
package fr.inria.corese.core.next.query.impl.parser;

import fr.inria.corese.core.next.data.impl.io.common.IOConstants;
import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF;
import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD;
import fr.inria.corese.core.next.impl.parser.antlr.SparqlParser;
Expand All @@ -9,6 +10,7 @@
import fr.inria.corese.core.next.query.impl.parser.semantic.support.VariableScopeAnalyzer;
import fr.inria.corese.core.next.query.impl.sparql.ast.*;
import fr.inria.corese.core.next.query.impl.sparql.ast.constraint.*;
import fr.inria.corese.core.next.query.impl.sparql.ast.path.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;

Expand All @@ -20,6 +22,8 @@
*/
public abstract class SparqlAstBuilder {

private static final String GENERATED_BLANK_NODE_PREFIX = IOConstants.BLANK_NODE_PREFIX + "b";

/**
* Parser options (e.g. for future use: strict mode, base IRI).
*/
Expand Down Expand Up @@ -56,6 +60,16 @@ public abstract class SparqlAstBuilder {
*/
protected final Deque<List<TriplePatternAst>> bgpStack = new ArrayDeque<>();

/**
* Counter for anonymous blank nodes created while expanding {@code [ ... ]} and {@code ( ... )} subjects.
*/
private int anonymousBlankNodeCounter;

/**
* Blank node labels already present in the query or generated by this builder.
*/
private final Set<String> blankNodeLabels = new HashSet<>();

/**
* Stack of currently open SELECT operations (top-level SELECT and nested SELECT subqueries).
*/
Expand Down Expand Up @@ -140,6 +154,10 @@ protected SparqlAstBuilder(SparqlParserOptions options) {
this.baseUri = options.getBaseIRI();
}

public void reserveBlankNodeLabels(Collection<String> labels) {
blankNodeLabels.addAll(Objects.requireNonNull(labels, "labels"));
}

// --- Construction entry points (called by listener) ---

public void setBaseUri(String uri) {
Expand Down Expand Up @@ -363,19 +381,24 @@ protected SelectFrame getCurrentSelectFrame() {
}

/**
* Add a triple pattern (?s ?p ?o) to the current BGP (TriplesBlock).
* Add a triple pattern to the current BGP (TriplesBlock).
* This must be called while inside a TriplesBlock.
*/
public void addTriple(TermAst s, TermAst p, TermAst o) {
public void addTriple(TermAst s, PathAst p, TermAst o) {
if (bgpStack.isEmpty()) {
// This should not happen if listener wiring is correct, but we fail loudly
// because BGP boundaries matter (TriplesBlock).
throw new IllegalStateException("addTriple() called outside of TriplesBlock (BGP). " +
"Ensure you call enterBgp() on enterTriplesBlock.");
}
bgpStack.peek().add(new TriplePatternAst(s, p, o));
}

/**
* Add a triple whose predicate is a single term (IRI, variable, etc.).
*/
public void addTriple(TermAst s, TermAst p, TermAst o) {
addTriple(s, new PredicatePathAst(p), o);
}

// --- Filters ---

/**
Expand Down Expand Up @@ -869,14 +892,15 @@ public TermAst termFromNumericLiteralUnsigned(SparqlParser.NumericLiteralUnsigne
}

public TermAst termFromBlankNode(SparqlParser.BlankNodeContext ctx) {
return this.iri(ctx.getText());
String label = ctx.getText();
blankNodeLabels.add(label);
return this.iri(label);
}

/**
* One {@code groupCondition}&nbsp;:&nbsp;{@code builtInCall | functionCall | '(' expression ('AS' var_)? ')' | var_}.
* <p>La forme {@code (expr AS ?v)} est résolue comme l’expression de regroupement.
* L’alias éventuel est capturé par {@link fr.inria.corese.core.next.query.impl.parser.listener.SolutionModifierFeature}
* puis porté par {@link GroupByAst}.
* <p>La forme {@code (expr AS ?v)} est résolue comme l’expression de regroupement (le nom optionnel rejoint la
* spec en étant porté par la projection SELECT&nbsp;; l’AST minimal ne le duplique pas ici).
*/
public TermAst termFromGroupCondition(SparqlParser.GroupConditionContext ctx) {
if (ctx.expression() != null) {
Expand Down Expand Up @@ -1278,12 +1302,225 @@ public TermAst termFromReplace(SparqlParser.StrReplaceExpressionContext ctx) {
}

/**
* Predicate as a property path.
* For simple triples without a composed path, this is just an iriRef or 'a'.
* Composed property paths will be expanded in a later phase if needed.
* Predicate as a SPARQL 1.1 property path.
*/
public TermAst termFromVerbPath(SparqlParser.VerbPathContext ctx) {
return this.iri(ctx.getText());
public PathAst pathFromVerbPath(SparqlParser.VerbPathContext ctx) {
return pathFromPath(ctx.path());
}

public PathAst pathFromPath(SparqlParser.PathContext ctx) {
return pathFromPathAlternative(ctx.pathAlternative());
}

private PathAst pathFromPathAlternative(SparqlParser.PathAlternativeContext ctx) {
return foldAlternatives(ctx.pathSequence().stream().map(this::pathFromPathSequence).toList());
}

private PathAst pathFromPathSequence(SparqlParser.PathSequenceContext ctx) {
return foldSequences(ctx.pathEltOrInverse().stream().map(this::pathFromPathEltOrInverse).toList());
}

private PathAst pathFromPathEltOrInverse(SparqlParser.PathEltOrInverseContext ctx) {
if (ctx.CARET() != null) {
return new InversePathAst(pathFromPathElt(ctx.pathElt()));
}
return pathFromPathElt(ctx.pathElt());
}

private PathAst pathFromPathElt(SparqlParser.PathEltContext ctx) {
PathAst primary = pathFromPathPrimary(ctx.pathPrimary());
SparqlParser.PathModContext mod = ctx.pathMod();
if (mod == null) {
return primary;
}
if (mod.QUESTION() != null) {
return new OptionalPathAst(primary);
}
if (mod.STAR() != null) {
return new ZeroOrMorePathAst(primary);
}
if (mod.PLUS() != null) {
return new OneOrMorePathAst(primary);
}
throw new QueryEvaluationException("Unexpected path modifier in " + ctx.getText());
}

private PathAst pathFromPathPrimary(SparqlParser.PathPrimaryContext ctx) {
if (ctx.iriRef() != null) {
return new PredicatePathAst(termFromIriRef(ctx.iriRef()));
}
if (ctx.A() != null) {
return new PredicatePathAst(iri("a"));
}
if (ctx.EXCLAMATION() != null) {
return pathFromPathNegatedPropertySet(ctx.pathNegatedPropertySet());
}
if (ctx.path() != null) {
return pathFromPath(ctx.path());
}
throw new QueryEvaluationException("Unexpected path primary in " + ctx.getText());
}

private PathAst pathFromPathNegatedPropertySet(SparqlParser.PathNegatedPropertySetContext ctx) {
List<PathAst> excluded;
if (ctx.L_PAREN() != null) {
excluded = ctx.pathOneInPropertySet().stream().map(this::pathFromPathOneInPropertySet).toList();
} else {
excluded = List.of(pathFromPathOneInPropertySet(ctx.pathOneInPropertySet().getFirst()));
}
return new NegatedPropertySetPathAst(excluded);
}

private PathAst pathFromPathOneInPropertySet(SparqlParser.PathOneInPropertySetContext ctx) {
if (ctx.CARET() != null) {
if (ctx.iriRef() != null) {
return new InversePathAst(new PredicatePathAst(termFromIriRef(ctx.iriRef())));
}
return new InversePathAst(new PredicatePathAst(iri("a")));
}
if (ctx.iriRef() != null) {
return new PredicatePathAst(termFromIriRef(ctx.iriRef()));
}
return new PredicatePathAst(iri("a"));
}

private PathAst foldAlternatives(List<PathAst> parts) {
if (parts.isEmpty()) {
throw new QueryEvaluationException("Empty property path alternative");
}
PathAst result = parts.getFirst();
for (int i = 1; i < parts.size(); i++) {
result = new AlternativePathAst(result, parts.get(i));
}
return result;
}

private PathAst foldSequences(List<PathAst> parts) {
if (parts.isEmpty()) {
throw new QueryEvaluationException("Empty property path sequence");
}
PathAst result = parts.getFirst();
for (int i = 1; i < parts.size(); i++) {
result = new SequencePathAst(result, parts.get(i));
}
return result;
}

/**
* Creates a fresh internal blank node label for expanded BGP triples.
*/
public TermAst newAnonymousBlankNode() {

@remiceres remiceres Jun 22, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This generates fresh blank nodes with labels like _:b0. That can collide with user-written blank node labels and make two different nodes become equal in the AST.

@Test
void generatedBlankNodeShouldNotCollideWithUserBlankNodeLabel() {
    SparqlParser parser = newParserDefault();

    QueryAst ast = parser.parse("""
            PREFIX ex: <http://example.org/>
            SELECT * WHERE {
              _:b0 ex:link [ ex:p ?o ] .
            }
            """);

    BgpAst bgp = whereBgp(ast);
    assertEquals(2, bgp.triples().size());

    TriplePatternAst inner = bgp.triples().getFirst();
    TriplePatternAst outer = bgp.triples().get(1);

    assertInstanceOf(IriAst.class, outer.subject());
    assertInstanceOf(IriAst.class, outer.object());
    assertNotEquals(outer.subject(), outer.object());
    assertNotEquals(outer.subject(), inner.subject());
}

String label;
do {
label = GENERATED_BLANK_NODE_PREFIX + anonymousBlankNodeCounter++;
} while (!blankNodeLabels.add(label));
return iri(label);
}

/**
* Expands a {@code propertyListPathNotEmpty} into triple patterns for the given subject.
*/
public void addTriplesFromPropertyListPath(
TermAst subject,
SparqlParser.PropertyListPathNotEmptyContext propertyList) {
var verbPaths = propertyList.verbPath();
var verbSimples = propertyList.verbSimple();
var objectLists = propertyList.objectListPath();

int verbPathIdx = 0;
int verbSimpleIdx = 0;

for (SparqlParser.ObjectListPathContext objectList : objectLists) {
PathAst predicate = predicateFromPropertyListPath(
verbPaths, verbSimples, verbPathIdx, verbSimpleIdx);
if (verbPathIdx < verbPaths.size()
&& (verbSimpleIdx >= verbSimples.size()
|| verbPaths.get(verbPathIdx).getStart().getTokenIndex()
< verbSimples.get(verbSimpleIdx).getStart().getTokenIndex())) {
verbPathIdx++;
} else {
verbSimpleIdx++;
}

for (TermAst object : termListFromObjectListPath(objectList)) {
addTriple(subject, predicate, object);
}
}
}

private PathAst predicateFromPropertyListPath(
List<SparqlParser.VerbPathContext> verbPaths,
List<SparqlParser.VerbSimpleContext> verbSimples,
int verbPathIdx,
int verbSimpleIdx) {
boolean useVerbPath = verbPathIdx < verbPaths.size()
&& (verbSimpleIdx >= verbSimples.size()
|| verbPaths.get(verbPathIdx).getStart().getTokenIndex()
< verbSimples.get(verbSimpleIdx).getStart().getTokenIndex());
if (useVerbPath) {
return pathFromVerbPath(verbPaths.get(verbPathIdx));
}
return new PredicatePathAst(termFromVerbSimple(verbSimples.get(verbSimpleIdx)));
}

/**
* Builds triple patterns for a {@code triplesNodePath} subject and returns its head term.
*/
public TermAst subjectFromTriplesNodePath(SparqlParser.TriplesNodePathContext ctx) {
if (ctx.blankNodePropertyListPath() != null) {
return subjectFromBlankNodePropertyListPath(ctx.blankNodePropertyListPath());
}
if (ctx.collectionPath() != null) {
return subjectFromCollectionPath(ctx.collectionPath());
}
throw new QueryEvaluationException("Unexpected triples node path: " + ctx.getText());
}

private TermAst subjectFromBlankNodePropertyListPath(
SparqlParser.BlankNodePropertyListPathContext ctx) {
TermAst blankNode = newAnonymousBlankNode();
if (ctx.propertyListPathNotEmpty() != null) {
addTriplesFromPropertyListPath(blankNode, ctx.propertyListPathNotEmpty());
}
return blankNode;
}

private TermAst subjectFromCollectionPath(SparqlParser.CollectionPathContext ctx) {
List<SparqlParser.GraphNodePathContext> nodes = ctx.graphNodePath();
if (nodes.isEmpty()) {
throw new QueryEvaluationException("Empty RDF collection in triple pattern");
}

TermAst head = newAnonymousBlankNode();
TermAst current = head;
for (int i = 0; i < nodes.size(); i++) {
addTriple(current, rdfTerm(RDF.first), termFromGraphNodePath(nodes.get(i)));
if (i == nodes.size() - 1) {
addTriple(current, rdfTerm(RDF.rest), rdfTerm(RDF.nil));
} else {
TermAst next = newAnonymousBlankNode();
addTriple(current, rdfTerm(RDF.rest), next);
current = next;
}
}
return head;
}

/**
* Graph node inside a property-path triple (variable/term, blank node property list, or collection).
*/
public TermAst termFromGraphNodePath(SparqlParser.GraphNodePathContext ctx) {
if (ctx.varOrTerm() != null) {
return termFromVarOrTerm(ctx.varOrTerm());
}
if (ctx.triplesNodePath() != null) {
return subjectFromTriplesNodePath(ctx.triplesNodePath());
}
throw new QueryEvaluationException("Unexpected graph node path: " + ctx.getText());
}

private TermAst rdfTerm(RDF term) {
return new IriAst("<" + term.getIRI().stringValue() + ">");
}

/**
Expand All @@ -1295,17 +1532,11 @@ public TermAst termFromVerbSimple(SparqlParser.VerbSimpleContext ctx) {

/**
* List of objects inside a property path triple.
* Blank node property lists and collections are not yet fully supported (raw text fallback).
*/
public List<TermAst> termListFromObjectListPath(SparqlParser.ObjectListPathContext ctx) {
List<TermAst> out = new ArrayList<>();
for (var objPath : ctx.objectPath()) {
var graphNodePath = objPath.graphNodePath();
if (graphNodePath.varOrTerm() != null) {
out.add(termFromVarOrTerm(graphNodePath.varOrTerm()));
} else {
out.add(this.iri(graphNodePath.getText()));
}
out.add(termFromGraphNodePath(objPath.graphNodePath()));
}
return out;
}
Expand Down
Loading
Loading