diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AbstractQueryBuilder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AbstractQueryBuilder.java index 2e25990cb6d..2ab2ba71b28 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AbstractQueryBuilder.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AbstractQueryBuilder.java @@ -25,17 +25,26 @@ import org.apache.jena.graph.FrontsNode ; import org.apache.jena.graph.Node ; import org.apache.jena.graph.NodeFactory ; +import org.apache.jena.graph.Triple; import org.apache.jena.graph.impl.LiteralLabelFactory ; import org.apache.jena.query.Query ; import org.apache.jena.query.QueryParseException; import org.apache.jena.rdf.model.Resource ; import org.apache.jena.riot.RiotException; +import org.apache.jena.riot.system.PrefixMap; import org.apache.jena.riot.system.PrefixMapFactory; +import org.apache.jena.riot.tokens.Token; +import org.apache.jena.riot.tokens.Tokenizer; +import org.apache.jena.riot.tokens.TokenizerFactory; import org.apache.jena.shared.PrefixMapping; import org.apache.jena.sparql.ARQInternalErrorException ; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.core.Var ; import org.apache.jena.sparql.expr.Expr; import org.apache.jena.sparql.expr.ExprVar ; +import org.apache.jena.sparql.path.P_Link; +import org.apache.jena.sparql.path.Path; +import org.apache.jena.sparql.path.PathParser; import org.apache.jena.sparql.syntax.ElementGroup; import org.apache.jena.sparql.util.ExprUtils; import org.apache.jena.sparql.util.NodeFactoryExtra ; @@ -76,6 +85,85 @@ public Node makeNode(Object o) { return makeNode( o, query.getPrefixMapping() ); } + private Object makeNodeOrPath(Object o) + { + return makeNodeOrPath(o, query.getPrefixMapping() ); + } + + private Object makeNodeOrPath(Object o, PrefixMapping pMapping) + { + if (o == null) { + return Node.ANY; + } + if (o instanceof Path) + { + return (Path)o; + } + if (o instanceof FrontsNode) { + return ((FrontsNode) o).asNode(); + } + + if (o instanceof Node) { + return (Node) o; + } + if (o instanceof String) { + try { + Path p = PathParser.parse((String) o, pMapping); + if (p instanceof P_Link) + { + return ((P_Link)p).getNode(); + } + return p; + } + catch (QueryParseException e) + { // try to parse vars + return makeNode( o, pMapping ); + } + catch (Exception e) + { + // expected in some cases -- do nothing + } + + } + return NodeFactory.createLiteral(LiteralLabelFactory.createTypedLiteral(o)); + } + + /** + * Make a triple path from the objects. + * + * For subject, predicate and objects nodes + * + * + * @param s The subject object + * @param p the predicate object + * @param o the object object. + * @return a TriplePath + */ + public TriplePath makeTriplePath(Object s, Object p, Object o) { + Object po = makeNodeOrPath( p ); + if (po instanceof Path) + { + return new TriplePath(makeNode(s), (Path)po, makeNode(o)); + } else + { + return new TriplePath( new Triple( makeNode(s), (Node)po, makeNode(o))); + } + + } + + /** * A convenience method to make an expression from a string. Evaluates the * expression with respect to the current query. diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AskBuilder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AskBuilder.java index a42f5c903f6..83aab1b51a0 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AskBuilder.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/AskBuilder.java @@ -30,8 +30,10 @@ import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple; import org.apache.jena.query.SortCondition; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.expr.Expr; import org.apache.jena.sparql.lang.sparql_11.ParseException; +import org.apache.jena.sparql.path.Path; /** * Build an ASK query. @@ -96,31 +98,45 @@ public AskBuilder from(Collection graphName) { getDatasetHandler().from(graphName); return this; } + + @Override + public AskBuilder addWhere(TriplePath t) { + getWhereHandler().addWhere(t); + return this; + } + @Override public AskBuilder addWhere(Triple t) { - getWhereHandler().addWhere(t); + getWhereHandler().addWhere(new TriplePath(t)); return this; } @Override public AskBuilder addWhere(FrontsTriple t) { - getWhereHandler().addWhere(t.asTriple()); + getWhereHandler().addWhere(new TriplePath(t.asTriple())); return this; } @Override public AskBuilder addWhere(Object s, Object p, Object o) { - addWhere(new Triple(makeNode(s), makeNode(p), makeNode(o))); + getWhereHandler().addWhere( makeTriplePath( s, p, o )); return this; } @Override - public AskBuilder addOptional(Triple t) { + public AskBuilder addOptional(TriplePath t) { getWhereHandler().addOptional(t); return this; } + + @Override + public AskBuilder addOptional(Triple t) { + getWhereHandler().addOptional(new TriplePath(t)); + return this; + } + @Override public AskBuilder addOptional(SelectBuilder t) { getWhereHandler().addOptional(t.getWhereHandler()); @@ -129,13 +145,13 @@ public AskBuilder addOptional(SelectBuilder t) { @Override public AskBuilder addOptional(FrontsTriple t) { - getWhereHandler().addOptional(t.asTriple()); + getWhereHandler().addOptional(new TriplePath(t.asTriple())); return this; } @Override public AskBuilder addOptional(Object s, Object p, Object o) { - addOptional(new Triple(makeNode(s), makeNode(p), makeNode(o))); + getWhereHandler().addOptional( makeTriplePath( s, p, o )); return this; } @@ -269,5 +285,4 @@ public SolutionModifierHandler getSolutionModifierHandler() { public Node list(Object... objs) { return getWhereHandler().list(objs); } - } \ No newline at end of file diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/ConstructBuilder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/ConstructBuilder.java index f31b14468db..b49757e3a53 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/ConstructBuilder.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/ConstructBuilder.java @@ -28,8 +28,10 @@ import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple; import org.apache.jena.query.SortCondition; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.expr.Expr; import org.apache.jena.sparql.lang.sparql_11.ParseException; +import org.apache.jena.sparql.path.Path; /** * Build an Construct query. @@ -190,29 +192,41 @@ public ConstructBuilder setOffset(int offset) { } @Override - public ConstructBuilder addWhere(Triple t) { + public ConstructBuilder addWhere(TriplePath t) { getWhereHandler().addWhere(t); return this; } + + @Override + public ConstructBuilder addWhere(Triple t) { + getWhereHandler().addWhere(new TriplePath(t)); + return this; + } @Override public ConstructBuilder addWhere(FrontsTriple t) { - getWhereHandler().addWhere(t.asTriple()); + getWhereHandler().addWhere(new TriplePath(t.asTriple())); return this; } @Override public ConstructBuilder addWhere(Object s, Object p, Object o) { - addWhere(new Triple(makeNode(s), makeNode(p), makeNode(o))); + getWhereHandler().addWhere( makeTriplePath( s, p, o )); return this; } @Override - public ConstructBuilder addOptional(Triple t) { + public ConstructBuilder addOptional(TriplePath t) { getWhereHandler().addOptional(t); return this; } + @Override + public ConstructBuilder addOptional(Triple t) { + getWhereHandler().addOptional(new TriplePath(t)); + return this; + } + @Override public ConstructBuilder addOptional(SelectBuilder t) { getWhereHandler().addOptional(t.getWhereHandler()); @@ -221,13 +235,13 @@ public ConstructBuilder addOptional(SelectBuilder t) { @Override public ConstructBuilder addOptional(FrontsTriple t) { - getWhereHandler().addOptional(t.asTriple()); + getWhereHandler().addOptional(new TriplePath(t.asTriple())); return this; } @Override public ConstructBuilder addOptional(Object s, Object p, Object o) { - addOptional(new Triple(makeNode(s), makeNode(p), makeNode(o))); + getWhereHandler().addOptional( makeTriplePath( s, p, o )); return this; } diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/SelectBuilder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/SelectBuilder.java index 69023f72336..3864cc928ac 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/SelectBuilder.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/SelectBuilder.java @@ -34,6 +34,7 @@ import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple; import org.apache.jena.query.SortCondition; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.expr.Expr; import org.apache.jena.sparql.lang.sparql_11.ParseException; @@ -284,38 +285,51 @@ public static String makeString(Object o) { } @Override - public SelectBuilder addWhere(Triple t) { + public SelectBuilder addWhere(TriplePath t ) + { getWhereHandler().addWhere(t); return this; } + + @Override + public SelectBuilder addWhere(Triple t) { + getWhereHandler().addWhere(new TriplePath(t)); + return this; + } @Override public SelectBuilder addWhere(FrontsTriple t) { - getWhereHandler().addWhere(t.asTriple()); + getWhereHandler().addWhere(new TriplePath(t.asTriple())); return this; } @Override public SelectBuilder addWhere(Object s, Object p, Object o) { - addWhere(new Triple(makeNode(s), makeNode(p), makeNode(o))); + getWhereHandler().addWhere( makeTriplePath( s, p, o )); return this; } + @Override + public SelectBuilder addOptional(TriplePath t) + { + getWhereHandler().addOptional( t ); + return this; + } @Override public SelectBuilder addOptional(Triple t) { - getWhereHandler().addOptional(t); + getWhereHandler().addOptional(new TriplePath(t)); return this; } @Override public SelectBuilder addOptional(FrontsTriple t) { - getWhereHandler().addOptional(t.asTriple()); + getWhereHandler().addOptional(new TriplePath(t.asTriple())); return this; } @Override public SelectBuilder addOptional(Object s, Object p, Object o) { - addOptional(new Triple(makeNode(s), makeNode(p), makeNode(o))); + getWhereHandler().addOptional( makeTriplePath( s, p, o )); return this; } diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/clauses/WhereClause.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/clauses/WhereClause.java index 42da1e76880..978255b8a60 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/clauses/WhereClause.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/clauses/WhereClause.java @@ -23,6 +23,7 @@ import org.apache.jena.graph.FrontsTriple ; import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple ; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.expr.Expr; import org.apache.jena.sparql.lang.sparql_11.ParseException ; @@ -36,16 +37,25 @@ public interface WhereClause> { /** - * Adds a triple as to the where clause. + * Adds a triple to the where clause. * * @param t - * The triple to add + * The triple path to add * @return The Builder for chaining. */ public T addWhere(Triple t); + + /** + * Adds a triple path to the where clause. + * + * @param t + * The triple path to add + * @return The Builder for chaining. + */ + public T addWhere(TriplePath t); /** - * Adds a triple as to the where clause. + * Adds a triple to the where clause. * * @param t * The triple to add @@ -54,9 +64,9 @@ public interface WhereClause> { public T addWhere(FrontsTriple t); /** - * Adds a triple to the where clause. + * Adds a triple or triple path to the where clause. * - * See {@link AbstractQueryBuilder#makeNode} for conversion of the param values. + * See {@link AbstractQueryBuilder#makeTriplePath} for conversion of the param values. * * @param s * The subject. @@ -77,6 +87,14 @@ public interface WhereClause> { */ public T addOptional(Triple t); + /** + * Adds an optional triple path to the where clause. + * + * @param t + * The triple path to add + * @return The Builder for chaining. + */ + public T addOptional(TriplePath t); /** * Adds an optional triple as to the where clause. * @@ -87,9 +105,9 @@ public interface WhereClause> { public T addOptional(FrontsTriple t); /** - * Adds an optional triple to the where clause. + * Adds an optional triple or triple path to the where clause. * - * See {@link AbstractQueryBuilder#makeNode} for conversion of the param values. + * See {@link AbstractQueryBuilder#makeTriplePath} for conversion of the param values. * * @param s * The subject. diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/handlers/WhereHandler.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/handlers/WhereHandler.java index b5303c6045e..0198006ca82 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/handlers/WhereHandler.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/handlers/WhereHandler.java @@ -27,6 +27,7 @@ import org.apache.jena.graph.NodeFactory; import org.apache.jena.graph.Triple; import org.apache.jena.query.Query; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.expr.Expr; import org.apache.jena.sparql.lang.sparql_11.ParseException; @@ -138,12 +139,19 @@ private ElementGroup getClause() { * @param t * The trip to test. */ - private static void testTriple(Triple t) { + private static void testTriple(TriplePath t) { // verify Triple is valid boolean validSubject = t.getSubject().isURI() || t.getSubject().isBlank() || t.getSubject().isVariable() || t.getSubject().equals(Node.ANY); - boolean validPredicate = t.getPredicate().isURI() || t.getPredicate().isVariable() - || t.getPredicate().equals(Node.ANY); + boolean validPredicate; + + if (t.isTriple()) { + validPredicate = t.getPredicate().isURI() || t.getPredicate().isVariable() + || t.getPredicate().equals(Node.ANY); + } else { + validPredicate = t.getPath() != null; + } + boolean validObject = t.getObject().isURI() || t.getObject().isLiteral() || t.getObject().isBlank() || t.getObject().isVariable() || t.getObject().equals(Node.ANY); @@ -155,7 +163,7 @@ private static void testTriple(Triple t) { } if (!validPredicate) { sb.append( - String.format("Predicate (%s) must be a URI , variable, or a wildcard. %n", t.getPredicate())); + String.format("Predicate (%s) must be a Path, URI , variable, or a wildcard. %n", t.getPredicate())); } if (!validObject) { sb.append(String.format("Object (%s) must be a URI, literal, blank, , variable, or a wildcard. %n", @@ -169,14 +177,14 @@ private static void testTriple(Triple t) { } /** - * Add the triple to the where clause + * Add the triple path to the where clause * * @param t - * The triple to add. + * The triple path to add. * @throws IllegalArgumentException - * If the triple is not a valid triple for a where clause. + * If the triple path is not a valid triple path for a where clause. */ - public void addWhere(Triple t) throws IllegalArgumentException { + public void addWhere(TriplePath t) throws IllegalArgumentException { testTriple(t); ElementGroup eg = getClause(); List lst = eg.getElements(); @@ -186,9 +194,9 @@ public void addWhere(Triple t) throws IllegalArgumentException { eg.addElement(epb); } else { Element e = lst.get(lst.size() - 1); - if (e instanceof ElementTriplesBlock) { + if (e instanceof ElementTriplesBlock && t.isTriple()) { ElementTriplesBlock etb = (ElementTriplesBlock) e; - etb.addTriple(t); + etb.addTriple(t.asTriple()); } else if (e instanceof ElementPathBlock) { ElementPathBlock epb = (ElementPathBlock) e; epb.addTriple(t); @@ -205,11 +213,11 @@ public void addWhere(Triple t) throws IllegalArgumentException { * Add an optional triple to the where clause * * @param t - * The triple to add. + * The triple path to add. * @throws IllegalArgumentException * If the triple is not a valid triple for a where clause. */ - public void addOptional(Triple t) throws IllegalArgumentException { + public void addOptional(TriplePath t) throws IllegalArgumentException { testTriple(t); ElementPathBlock epb = new ElementPathBlock(); epb.addTriple(t); @@ -398,13 +406,13 @@ public Node list(Object... objs) { Node lastObject = retval; for (int i = 0; i < objs.length; i++) { Node n = AbstractQueryBuilder.makeNode(objs[i], query.getPrefixMapping()); - addWhere(new Triple(lastObject, RDF.first.asNode(), n)); + addWhere(new TriplePath(new Triple(lastObject, RDF.first.asNode(), n))); if (i + 1 < objs.length) { Node nextObject = NodeFactory.createBlankNode(); - addWhere(new Triple(lastObject, RDF.rest.asNode(), nextObject)); + addWhere(new TriplePath(new Triple(lastObject, RDF.rest.asNode(), nextObject))); lastObject = nextObject; } else { - addWhere(new Triple(lastObject, RDF.rest.asNode(), RDF.nil.asNode())); + addWhere(new TriplePath(new Triple(lastObject, RDF.rest.asNode(), RDF.nil.asNode()))); } } diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java index 23b522bd1d5..a7896dc85cd 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java @@ -27,9 +27,14 @@ import org.apache.jena.graph.impl.LiteralLabelFactory; import org.apache.jena.query.Query; import org.apache.jena.query.QueryFactory; +import org.apache.jena.shared.PrefixMapping; +import org.apache.jena.shared.impl.PrefixMappingImpl; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.expr.E_Random; import org.apache.jena.sparql.lang.sparql_11.ParseException; +import org.apache.jena.sparql.path.Path; +import org.apache.jena.sparql.path.PathParser; import org.apache.jena.sparql.syntax.Element; import org.apache.jena.sparql.syntax.ElementGroup; import org.apache.jena.sparql.syntax.ElementTriplesBlock; @@ -86,6 +91,18 @@ public void testAddOptionalString() { } + @ContractTest + public void testAddOptionalStringWithPath() { + WhereClause whereClause = getProducer().newInstance(); + AbstractQueryBuilder builder = whereClause.addOptional("", + "/", "three"); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + uri("one") + SPACE + uri("two")+"/"+uri("dos") + SPACE + + quote("three") + presentStringType() + OPT_SPACE + + CLOSE_CURLY + CLOSE_CURLY, builder.buildString()); + + } + @ContractTest public void testAddOptionalObjects() { WhereClause whereClause = getProducer().newInstance(); @@ -101,9 +118,9 @@ public void testAddOptionalObjects() { @ContractTest public void testAddOptionalTriple() { WhereClause whereClause = getProducer().newInstance(); - AbstractQueryBuilder builder = whereClause.addOptional(new Triple( + AbstractQueryBuilder builder = whereClause.addOptional( NodeFactory.createURI("one"), NodeFactory.createURI("two"), - NodeFactory.createURI("three"))); + NodeFactory.createURI("three")); assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE @@ -111,6 +128,38 @@ public void testAddOptionalTriple() { builder.buildString()); } + @ContractTest + public void testAddOptionalTriplePath() { + WhereClause whereClause = getProducer().newInstance(); + PrefixMapping pmap = new PrefixMappingImpl(); + pmap.setNsPrefix("ts", "urn:test:"); + Path path = PathParser.parse( "ts:two/ts:dos", pmap); + AbstractQueryBuilder builder = whereClause.addOptional(new TriplePath( + NodeFactory.createURI("one"), path, + NodeFactory.createURI("three"))); + + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + uri("one") + SPACE + uri("urn:test:two")+"/"+uri("urn:test:dos") + SPACE + + uri("three") + OPT_SPACE + CLOSE_CURLY, + builder.buildString()); + } + + @ContractTest + public void testAddOptionalObjectsWithPath() { + WhereClause whereClause = getProducer().newInstance(); + PrefixMapping pmap = new PrefixMappingImpl(); + pmap.setNsPrefix("ts", "urn:test:"); + Path path = PathParser.parse( "ts:two/ts:dos", pmap); + AbstractQueryBuilder builder = whereClause.addOptional( + NodeFactory.createURI("one"), path, + NodeFactory.createURI("three")); + + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + uri("one") + SPACE + uri("urn:test:two")+"/"+uri("urn:test:dos") + SPACE + + uri("three") + OPT_SPACE + CLOSE_CURLY, + builder.buildString()); + } + @ContractTest public void testAddOptionalGroupPattern() throws ParseException { @@ -165,7 +214,7 @@ public void testAddUnion() { sb.addPrefix("pfx", "uri").addVar("?x") .addWhere("", "", "three"); WhereClause whereClause = getProducer().newInstance(); - whereClause.getWhereHandler().addWhere(Triple.ANY); + whereClause.getWhereHandler().addWhere( new TriplePath(Triple.ANY)); AbstractQueryBuilder builder = whereClause.addUnion(sb); String str = builder.buildString(); diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java index 8a7dda9a6e9..aebaceefb32 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java @@ -31,9 +31,14 @@ import org.apache.jena.query.Query; import org.apache.jena.query.QueryFactory; import org.apache.jena.rdf.model.ResourceFactory; +import org.apache.jena.shared.PrefixMapping; +import org.apache.jena.shared.impl.PrefixMappingImpl; +import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.expr.E_Random; import org.apache.jena.sparql.lang.sparql_11.ParseException; +import org.apache.jena.sparql.path.Path; +import org.apache.jena.sparql.path.PathParser; import org.apache.jena.vocabulary.RDF; import org.junit.Assert; import org.junit.Before; @@ -54,8 +59,8 @@ public void setup() { public void testAddAllOnEmpty() { Query query2 = new Query(); WhereHandler handler2 = new WhereHandler(query2); - handler2.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), - NodeFactory.createLiteral("three"))); + handler2.addWhere(new TriplePath(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), + NodeFactory.createLiteral("three")))); handler.addAll(handler2); assertContainsRegex( @@ -65,11 +70,11 @@ public void testAddAllOnEmpty() { @Test public void testAddAllPopulatedEmpty() { - handler.addWhere(Triple.ANY); + handler.addWhere(new TriplePath(Triple.ANY)); Query query2 = new Query(); WhereHandler handler2 = new WhereHandler(query2); - handler2.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), - NodeFactory.createLiteral("three"))); + handler2.addWhere(new TriplePath(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), + NodeFactory.createLiteral("three")))); handler.addAll(handler2); assertContainsRegex(WHERE + OPEN_CURLY + "ANY" + SPACE + "ANY" + SPACE + "ANY" + DOT + SPACE + uri("one") @@ -78,8 +83,8 @@ public void testAddAllPopulatedEmpty() { @Test public void addWhereTriple() { - handler.addWhere( - new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three"))); + handler.addWhere( new TriplePath( + new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three")))); assertContainsRegex( WHERE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + uri("three") + OPT_SPACE + CLOSE_CURLY, query.toString()); @@ -87,15 +92,26 @@ public void addWhereTriple() { @Test public void testAddWhereObjects() { - handler.addWhere(new Triple(NodeFactory.createURI("one"), ResourceFactory.createResource("two").asNode(), - ResourceFactory.createLangLiteral("three", "en-US").asNode())); + handler.addWhere(new TriplePath(new Triple(NodeFactory.createURI("one"), ResourceFactory.createResource("two").asNode(), + ResourceFactory.createLangLiteral("three", "en-US").asNode()))); assertContainsRegex(WHERE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + quote("three") + "@en-US" + OPT_SPACE + CLOSE_CURLY, query.toString()); } + @Test + public void testAddWhereObjectsWithPath() { + PrefixMapping pmap = new PrefixMappingImpl(); + pmap.setNsPrefix("ts", "urn:test:"); + Path path = PathParser.parse( "ts:two/ts:dos", pmap); + handler.addWhere(new TriplePath(NodeFactory.createURI("one"), path, + ResourceFactory.createLangLiteral("three", "en-US").asNode())); + assertContainsRegex(WHERE + OPEN_CURLY + uri("one") + SPACE + + uri("urn:test:two")+"/"+uri("urn:test:dos") + SPACE + quote("three") + "@en-US" + + OPT_SPACE + CLOSE_CURLY, query.toString()); + } @Test public void testAddWhereAnonymous() { - handler.addWhere(new Triple(Node.ANY, RDF.first.asNode(), Node.ANY)); + handler.addWhere(new TriplePath(new Triple(Node.ANY, RDF.first.asNode(), Node.ANY))); assertContainsRegex(WHERE + OPEN_CURLY + "ANY" + SPACE + uri("http://www\\.w3\\.org/1999/02/22-rdf-syntax-ns#first") + SPACE + "ANY" + OPT_SPACE + CLOSE_CURLY, query.toString()); @@ -103,15 +119,15 @@ public void testAddWhereAnonymous() { @Test public void testAddOptionalStrings() { - handler.addOptional( - new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three"))); + handler.addOptional( new TriplePath( + new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three")))); assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + uri("three") + OPT_SPACE + CLOSE_CURLY + CLOSE_CURLY, query.toString()); } @Test public void testAddOptionalAnonymous() { - handler.addOptional(new Triple(Node.ANY, RDF.first.asNode(), Node.ANY)); + handler.addOptional(new TriplePath(new Triple(Node.ANY, RDF.first.asNode(), Node.ANY))); assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + OPEN_CURLY + "ANY" + SPACE + uri("http://www\\.w3\\.org/1999/02/22-rdf-syntax-ns#first") + SPACE + "ANY" + OPT_SPACE + CLOSE_CURLY + CLOSE_CURLY, query.toString()); @@ -127,8 +143,8 @@ public void testAddOptionalWhereHandler() throws ParseException { Var x = Var.alloc("x"); Node n123 = NodeFactory.createLiteral(LiteralLabelFactory.createTypedLiteral(123)); - pattern.addWhere(new Triple(s, q, n123)); - pattern.addWhere(new Triple(s, v, x)); + pattern.addWhere(new TriplePath(new Triple(s, q, n123))); + pattern.addWhere(new TriplePath(new Triple(s, v, x))); pattern.addFilter("?x>56"); handler.addOptional(pattern); @@ -142,16 +158,29 @@ public void testAddOptionalWhereHandler() throws ParseException { @Test public void testAddOptionalObjects() { - handler.addOptional(new Triple(NodeFactory.createURI("one"), ResourceFactory.createResource("two").asNode(), - ResourceFactory.createLangLiteral("three", "en-US").asNode())); + handler.addOptional(new TriplePath(new Triple(NodeFactory.createURI("one"), ResourceFactory.createResource("two").asNode(), + ResourceFactory.createLangLiteral("three", "en-US").asNode()))); assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + quote("three") + "@en-US" + OPT_SPACE + CLOSE_CURLY + CLOSE_CURLY, query.toString()); } + + @Test + public void testAddOptionalObjectsWithPath() { + PrefixMapping pmap = new PrefixMappingImpl(); + pmap.setNsPrefix("ts", "urn:test:"); + Path path = PathParser.parse( "ts:two/ts:dos", pmap); + handler.addOptional(new TriplePath(NodeFactory.createURI("one"), path, + ResourceFactory.createLangLiteral("three", "en-US").asNode())); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + OPEN_CURLY + uri("one") + + SPACE + uri("urn:test:two")+"/"+uri("urn:test:dos") + + SPACE + quote("three") + "@en-US" + OPT_SPACE + CLOSE_CURLY + CLOSE_CURLY, query.toString()); + } + @Test public void testAddWhereStrings() { - handler.addWhere( - new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three"))); + handler.addWhere(new TriplePath( + new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three")))); assertContainsRegex( WHERE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + uri("three") + OPT_SPACE + CLOSE_CURLY, query.toString()); @@ -228,8 +257,8 @@ public void testAddUnion() { @Test public void testAddUnionToExisting() { - handler.addWhere( - new Triple(NodeFactory.createURI("s"), NodeFactory.createURI("p"), NodeFactory.createURI("o"))); + handler.addWhere( new TriplePath( + new Triple(NodeFactory.createURI("s"), NodeFactory.createURI("p"), NodeFactory.createURI("o")))); SelectBuilder sb = new SelectBuilder(); sb.addWhere( new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three"))); @@ -252,8 +281,8 @@ public void testAddUnionWithVar() { @Test public void testAddUnionToExistingWithVar() { - handler.addWhere( - new Triple(NodeFactory.createURI("s"), NodeFactory.createURI("p"), NodeFactory.createURI("o"))); + handler.addWhere( new TriplePath( + new Triple(NodeFactory.createURI("s"), NodeFactory.createURI("p"), NodeFactory.createURI("o")))); SelectBuilder sb = new SelectBuilder().addVar("x").addWhere( new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three"))); @@ -267,8 +296,8 @@ public void testAddUnionToExistingWithVar() { public void addGraph() { WhereHandler handler2 = new WhereHandler(new Query()); - handler2.addWhere( - new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three"))); + handler2.addWhere(new TriplePath( + new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), NodeFactory.createURI("three")))); handler.addGraph(NodeFactory.createURI("graph"), handler2); assertContainsRegex(WHERE + OPEN_CURLY + "GRAPH" + SPACE + uri("graph") + SPACE + OPEN_CURLY + uri("one") @@ -279,7 +308,7 @@ public void addGraph() { @Test public void testSetVarsInTriple() { Var v = Var.alloc("v"); - handler.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), v)); + handler.addWhere(new TriplePath(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), v))); assertContainsRegex( WHERE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + var("v") + OPT_SPACE + CLOSE_CURLY, query.toString()); @@ -309,7 +338,7 @@ public void testSetVarsInFilter() throws ParseException { @Test public void testSetVarsInOptional() { Var v = Var.alloc("v"); - handler.addOptional(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), v)); + handler.addOptional(new TriplePath(new Triple(NodeFactory.createURI("one"), NodeFactory.createURI("two"), v))); assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + OPEN_CURLY + uri("one") + SPACE + uri("two") + SPACE + var("v") + OPT_SPACE + CLOSE_CURLY + CLOSE_CURLY, query.toString()); Map values = new HashMap<>(); @@ -386,8 +415,8 @@ public void testList() { @Test public void testListInTriple() { - handler.addWhere(new Triple(handler.list("", "?var", "'three'"), - ResourceFactory.createResource("foo").asNode(), ResourceFactory.createResource("bar").asNode())); + handler.addWhere(new TriplePath(new Triple(handler.list("", "?var", "'three'"), + ResourceFactory.createResource("foo").asNode(), ResourceFactory.createResource("bar").asNode()))); assertContainsRegex("_:b0" + SPACE + uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#first") + SPACE + uri("one") + SEMI + SPACE + uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest") + SPACE + "_:b1"