From ee62b6540f795ddeb7ef7ee2eed2f2ac0d223d5b Mon Sep 17 00:00:00 2001 From: Claude Warren Date: Sun, 30 Sep 2018 11:01:22 +0100 Subject: [PATCH 1/4] closes JENA=1602 --- jena-extras/jena-querybuilder/.gitignore | 1 + .../jena/arq/querybuilder/UpdateBuilder.java | 172 ++++++++- .../updatebuilder/CollectionQuadHolder.java | 130 +++++++ .../updatebuilder/ModelQuadHolder.java | 74 ++++ ...ereProcessor.java => WhereQuadHolder.java} | 6 +- .../CollectionQuadHolderTest.java | 330 ++++++++++++++++++ .../updatebuilder/ModelQuadHolderTest.java | 82 +++++ .../updatebuilder/QBQuadHolderTest.java | 202 +++++++++++ .../updatebuilder/SingleQuadHolderTest.java | 100 ++++++ .../updatebuilder/WhereQuadHolderTest.java | 202 +++++++++++ jena-maven-tools/pom.xml | 5 +- 11 files changed, 1294 insertions(+), 10 deletions(-) create mode 100644 jena-extras/jena-querybuilder/.gitignore create mode 100644 jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolder.java create mode 100644 jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolder.java rename jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/{WhereProcessor.java => WhereQuadHolder.java} (98%) create mode 100644 jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java create mode 100644 jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java create mode 100644 jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java create mode 100644 jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java create mode 100644 jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java diff --git a/jena-extras/jena-querybuilder/.gitignore b/jena-extras/jena-querybuilder/.gitignore new file mode 100644 index 00000000000..d86b3dbb07d --- /dev/null +++ b/jena-extras/jena-querybuilder/.gitignore @@ -0,0 +1 @@ +/.project_old diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/UpdateBuilder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/UpdateBuilder.java index 2fb8fc84f27..44b9a9340ba 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/UpdateBuilder.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/UpdateBuilder.java @@ -29,16 +29,19 @@ import org.apache.jena.arq.querybuilder.clauses.PrologClause; import org.apache.jena.arq.querybuilder.clauses.WhereClause; import org.apache.jena.arq.querybuilder.handlers.WhereHandler; +import org.apache.jena.arq.querybuilder.updatebuilder.CollectionQuadHolder; +import org.apache.jena.arq.querybuilder.updatebuilder.ModelQuadHolder; import org.apache.jena.arq.querybuilder.updatebuilder.PrefixHandler; import org.apache.jena.arq.querybuilder.updatebuilder.QBQuadHolder; import org.apache.jena.arq.querybuilder.updatebuilder.QuadHolder; import org.apache.jena.arq.querybuilder.updatebuilder.SingleQuadHolder; -import org.apache.jena.arq.querybuilder.updatebuilder.WhereProcessor; +import org.apache.jena.arq.querybuilder.updatebuilder.WhereQuadHolder; import org.apache.jena.graph.FrontsTriple; import org.apache.jena.graph.Node; import org.apache.jena.graph.NodeFactory; import org.apache.jena.graph.Triple; import org.apache.jena.query.QueryParseException; +import org.apache.jena.rdf.model.Model; import org.apache.jena.rdf.model.Resource; import org.apache.jena.shared.PrefixMapping; import org.apache.jena.sparql.core.Quad; @@ -65,7 +68,7 @@ public class UpdateBuilder { private final PrefixHandler prefixHandler; - private final WhereProcessor whereProcessor; + private final WhereQuadHolder whereProcessor; private List inserts = new ArrayList(); private List deletes = new ArrayList(); private Map values; @@ -76,7 +79,7 @@ public class UpdateBuilder { */ public UpdateBuilder() { this.prefixHandler = new PrefixHandler(); - this.whereProcessor = new WhereProcessor(prefixHandler); + this.whereProcessor = new WhereQuadHolder(prefixHandler); this.values = new HashMap(); this.with = null; } @@ -101,7 +104,7 @@ public UpdateBuilder(PrologClause prologClause) { */ public UpdateBuilder(PrefixMapping pMap) { this.prefixHandler = new PrefixHandler(pMap); - this.whereProcessor = new WhereProcessor(prefixHandler); + this.whereProcessor = new WhereQuadHolder(prefixHandler); } // conver a collection of QuadHolder to an iterator on quads. @@ -358,7 +361,85 @@ public UpdateBuilder addInsert(Object g, Triple t) { inserts.add(new SingleQuadHolder(q)); return this; } + + /** + * Add all the statements in the model to the insert statement. + * + * @param model The model to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addInsert(Model model) { + inserts.add(new ModelQuadHolder( model )); + return this; + } + + /** + * Add all the statements in the model to the insert statement. + * + * @param collection The triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addInsert(Collection collection) { + inserts.add(new CollectionQuadHolder( collection )); + return this; + } + + /** + * Add all the statements in the model to the insert statement. + * + * @param iter The iterator of triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addInsert(Iterator iter) { + inserts.add(new CollectionQuadHolder( iter )); + return this; + } + + /** + * Add all the statements in the model a specified graph to the insert statement. + * + * The graph object is converted by a call to makeNode(). + * + * @see #makeNode(Object) + * @param g + * the graph for the triple. + * @param model + * the model to add. + * @return this builder for chaining. + */ + public UpdateBuilder addInsert(Object g, Model model) { + inserts.add( new ModelQuadHolder( + AbstractQueryBuilder.makeNode(g, prefixHandler.getPrefixes()), + model)); + return this; + } + /** + * Add all the statements in the model to the insert statement. + * + * @param collection The triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addInsert(Object g, Collection collection) { + inserts.add(new CollectionQuadHolder( + AbstractQueryBuilder.makeNode(g, prefixHandler.getPrefixes()), + collection )); + return this; + } + + /** + * Add all the statements in the model to the insert statement. + * + * @param iter The iterator of triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addInsert(Object g, Iterator iter) { + inserts.add(new CollectionQuadHolder( + AbstractQueryBuilder.makeNode(g, prefixHandler.getPrefixes()), + iter )); + return this; + } + /** * Add the statements from the where clause in the specified query builder * to the insert statement. @@ -479,6 +560,89 @@ public UpdateBuilder addDelete(Object g, Triple t) { return this; } + /** + * Add all the statements in the model to the delete statement. + * + * @param model The model to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addDelete(Model model) { + deletes.add(new ModelQuadHolder( model )); + return this; + } + + /** + * Add all the statements in the model to the delete statement. + * + * @param collection The collection of triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addDelete(Collection collection) { + deletes.add(new CollectionQuadHolder( collection )); + return this; + } + + /** + * Add all the statements in the model to the delete statement. + * + * @param iter The iterator of triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addDelete(Iterator iter) { + deletes.add(new CollectionQuadHolder( iter )); + return this; + } + + /** + * Add all the statements in the model a specified graph to the delete statement. + * + * The graph object is converted by a call to makeNode(). + * + * @see #makeNode(Object) + * @param g + * the graph for the triples. + * @param model + * the model to add. + * @return this builder for chaining. + */ + public UpdateBuilder addDelete(Object g, Model model) { + deletes.add( new ModelQuadHolder( + AbstractQueryBuilder.makeNode(g, prefixHandler.getPrefixes()), + model)); + return this; + } + + + /** + * Add all the statements in the model to the delete statement. + * + * @param g + * the graph for the triples. + * @param collection The collection of triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addDelete(Object g, Collection collection) { + deletes.add(new CollectionQuadHolder( + AbstractQueryBuilder.makeNode(g, prefixHandler.getPrefixes()), + collection )); + return this; + } + + /** + * Add all the statements in the model to the delete statement. + * + * @param g + * the graph for the triples. + * @param iter The iterator of triples to insert. + * @return this builder for chaining. + */ + public UpdateBuilder addDelete(Object g, Iterator iter) { + deletes.add(new CollectionQuadHolder( + AbstractQueryBuilder.makeNode(g, prefixHandler.getPrefixes()), + iter )); + return this; + } + /** * Add the statements from the where clause in the specified query builder * to the delete statement. diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolder.java new file mode 100644 index 00000000000..e9116a57989 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolder.java @@ -0,0 +1,130 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +import org.apache.jena.graph.Node; +import org.apache.jena.graph.Triple; +import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.WrappedIterator; + +/** + * An QuadHolder that creates quads from a collection or iterator of triples. + * + */ +public class CollectionQuadHolder implements QuadHolder { + + private final Set collection; + private final Node defaultGraphName; + private Map values; + + /** + * Constructor. + * + * @param graph + * the default graph name for the triples + * @param triples + * the collection of triples. + */ + public CollectionQuadHolder(final Node graph, Collection triples) { + this.collection = new HashSet(); + this.collection.addAll( triples ); + defaultGraphName = graph; + } + + /** + * Constructor. + * + * @param graph + * the default graph name for the triples + * @param triples + * the iterator of triples. + */ + public CollectionQuadHolder(final Node graph, Iterator triples) { + this.collection = WrappedIterator.create( triples ).toSet(); + defaultGraphName = graph; + } + + /** + * Constructor. Uses Quad.defaultGraphNodeGenerated for the graph name. + * + * @see Quad#defaultGraphNodeGenerated + * @param triples + * the collection of triples. + */ + public CollectionQuadHolder(final Collection triples) { + this( Quad.defaultGraphNodeGenerated, triples ); + } + + /** + * Constructor. + * + * @param triples + * the iterator of triples. + */ + public CollectionQuadHolder(Iterator triples) { + this.collection = WrappedIterator.create( triples ).toSet(); + defaultGraphName = Quad.defaultGraphNodeGenerated; + } + + private Node valueMap( Node n ) + { + if (n.isVariable()) + { + Var v = Var.alloc(n); + Node n2 = values.get( n ); + return n2==null?n:n2; + } + return n; + } + + @Override + public ExtendedIterator getQuads() { + if (values == null) + { + values = Collections.emptyMap(); + } + return WrappedIterator.create(collection.iterator()) + .mapWith( triple -> new Triple( + valueMap(triple.getSubject()), + valueMap(triple.getPredicate()), + valueMap(triple.getObject()) + )) + .mapWith( triple -> new Quad( defaultGraphName, triple ) ); + } + + + + /** + * This implementation does nothing. + */ + @Override + public QuadHolder setValues(final Map values) { + this.values = values; + return this; + } + +} diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolder.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolder.java new file mode 100644 index 00000000000..04661f77ac9 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolder.java @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import java.util.Map; + +import org.apache.jena.graph.Node; +import org.apache.jena.rdf.model.Model; +import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.util.iterator.ExtendedIterator; + +/** + * An QuadHolder that manages extracts all statements from a model as quads. + * + */ +public class ModelQuadHolder implements QuadHolder { + + private final Model model; + private final Node defaultGraphName; + + /** + * Constructor. + * + * @param graph + * the default graph name for the triples + * @param model + * the model that is providing the triples. + */ + public ModelQuadHolder(final Node graph, final Model model) { + this.model = model; + defaultGraphName = graph; + } + + /** + * Constructor. Uses Quad.defaultGraphNodeGenerated for the graph name. + * + * @see Quad#defaultGraphNodeGenerated + * @param model + * the model that is providing the triples. + */ + public ModelQuadHolder(final Model model) { + this( Quad.defaultGraphNodeGenerated, model ); + } + + @Override + public ExtendedIterator getQuads() { + return model.listStatements().mapWith( stmt -> new Quad( defaultGraphName, stmt.asTriple() ) ); + } + + /** + * This implementation does nothing. + */ + @Override + public QuadHolder setValues(final Map values) { + return this; + } + +} diff --git a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereProcessor.java b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolder.java similarity index 98% rename from jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereProcessor.java rename to jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolder.java index 8403e20e8f9..b0a96f75170 100644 --- a/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereProcessor.java +++ b/jena-extras/jena-querybuilder/src/main/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolder.java @@ -48,7 +48,7 @@ * SPARQL 11 Query Language - Group Graph Pattern * */ -public class WhereProcessor implements QuadHolder { +public class WhereQuadHolder implements QuadHolder { private Element whereClause; private final PrefixHandler prefixHandler; @@ -59,7 +59,7 @@ public class WhereProcessor implements QuadHolder { * @param prefixHandler * the prefix handler to use. */ - public WhereProcessor(PrefixHandler prefixHandler) { + public WhereQuadHolder(PrefixHandler prefixHandler) { this.prefixHandler = prefixHandler; } @@ -374,7 +374,7 @@ public void addBind(String expression, Var var) throws ParseException { * the value map to use * @return A new Element instance with the values changed. */ - public WhereProcessor setVars(Map values) { + public WhereQuadHolder setVars(Map values) { if ( whereClause != null) { /* process when values are empty as rewriter handles Node_Variable to Var translation. * diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java new file mode 100644 index 00000000000..d088f047aff --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java @@ -0,0 +1,330 @@ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.apache.jena.graph.Node; +import org.apache.jena.graph.NodeFactory; +import org.apache.jena.graph.Triple; +import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.WrappedIterator; +import org.junit.Test; + +public class CollectionQuadHolderTest { + + private CollectionQuadHolder holder; + + @Test + public void namedGraphTest_List() + { + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + + holder = new CollectionQuadHolder( g, tLst ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void namedGraphTest_List_Var() + { + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p, o2 ) ); + + holder = new CollectionQuadHolder( g, tLst ); + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List aLst = new ArrayList(); + aLst.add( new Triple( s, p2, o ) ); + aLst.add( new Triple( s2, p2, o2 ) ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, aLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, aLst.get(1)), lst.get(1)); + } + + @Test + public void namedGraphTest_Iterator() + { + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + + holder = new CollectionQuadHolder( g, tLst.iterator() ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void namedGraphTest_Iterator_Var() + { + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p, o2 ) ); + + holder = new CollectionQuadHolder( g, tLst.iterator() ); + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List aLst = new ArrayList(); + aLst.add( new Triple( s, p2, o ) ); + aLst.add( new Triple( s2, p2, o2 ) ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, aLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, aLst.get(1)), lst.get(1)); + } + + + + @Test + public void anonymousGraphTest_List() + { + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + + holder = new CollectionQuadHolder( tLst ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)), lst.get(1)); + } + + @Test + public void anonymousGraphTest_List_Var() + { + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p, o2 ) ); + + holder = new CollectionQuadHolder( tLst ); + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List aLst = new ArrayList(); + aLst.add( new Triple( s, p2, o ) ); + aLst.add( new Triple( s2, p2, o2 ) ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, aLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, aLst.get(1)), lst.get(1)); + } + + + @Test + public void anonymousGraphTest_Iterator() + { + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + + holder = new CollectionQuadHolder( tLst.iterator() ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)), lst.get(1)); + } + + @Test + public void anonymousGraphTest_Iterator_Var() + { + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p, o2 ) ); + + holder = new CollectionQuadHolder( tLst.iterator() ); + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List aLst = new ArrayList(); + aLst.add( new Triple( s, p2, o ) ); + aLst.add( new Triple( s2, p2, o2 ) ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, aLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, aLst.get(1)), lst.get(1)); + } + +// @Test +// public void anonymousGraphTest_var() +// { +// Node g = NodeFactory.createURI( "g" ); +// Node s = NodeFactory.createURI( "s" ); +// Node p = NodeFactory.createVariable( "p" ); +// Node o = NodeFactory.createURI( "o" ); +// Triple triple = new Triple( s, p, o ); +// Quad quad = new Quad( Quad.defaultGraphNodeGenerated, s, p, o ); +// holder = new SingleQuadHolder( triple ); +// List lst = holder.getQuads().toList(); +// assertEquals( 1, lst.size() ); +// assertEquals( quad, lst.get(0)); +// +// Map map = new HashMap<>(); +// Node p2 = NodeFactory.createURI( "p2" ); +// map.put( Var.alloc(p), p2); +// holder.setValues( map ); +// Quad quad2 = new Quad( Quad.defaultGraphNodeGenerated, s, p2, o ); +// lst = holder.getQuads().toList(); +// assertEquals( 1, lst.size() ); +// assertEquals( quad2, lst.get(0)); +// +// /** +// * Constructor. +// * +// * @param graph +// * the default graph name for the triples +// * @param triples +// * the collection of triples. +// */ +// public CollectionQuadHolder(final Node graph, Collection triples) { +// this.collection = new HashSet(); +// this.collection.addAll( triples ); +// defaultGraphName = graph; +// } +// +// /** +// * Constructor. +// * +// * @param graph +// * the default graph name for the triples +// * @param triples +// * the iterator of triples. +// */ +// public CollectionQuadHolder(final Node graph, Iterator triples) { +// this.collection = WrappedIterator.create( triples ).toSet(); +// defaultGraphName = graph; +// } +// +// /** +// * Constructor. Uses Quad.defaultGraphNodeGenerated for the graph name. +// * +// * @see Quad#defaultGraphNodeGenerated +// * @param triples +// * the collection of triples. +// */ +// public CollectionQuadHolder(final Collection triples) { +// this( Quad.defaultGraphNodeGenerated, triples ); +// } +// +// /** +// * Constructor. +// * +// * @param triples +// * the iterator of triples. +// */ +// public CollectionQuadHolder(Iterator triples) { +// this.collection = WrappedIterator.create( triples ).toSet(); +// defaultGraphName = Quad.defaultGraphNodeGenerated; +// } +// +// @Override +// public ExtendedIterator getQuads() { +// return WrappedIterator.create(collection.iterator()) +// .mapWith( triple -> new Quad( defaultGraphName, triple ) ); +// } +// +// /** +// * This implementation does nothing. +// */ +// @Override +// public QuadHolder setValues(final Map values) { +// return this; +// } +} diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java new file mode 100644 index 00000000000..16a62044482 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java @@ -0,0 +1,82 @@ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.jena.graph.Node; +import org.apache.jena.graph.NodeFactory; +import org.apache.jena.graph.Triple; +import org.apache.jena.rdf.model.Model; +import org.apache.jena.rdf.model.ModelFactory; +import org.apache.jena.rdf.model.Property; +import org.apache.jena.rdf.model.RDFNode; +import org.apache.jena.rdf.model.Resource; +import org.apache.jena.rdf.model.ResourceFactory; +import org.apache.jena.sparql.core.Quad; +import org.junit.Test; + +public class ModelQuadHolderTest { + + private Model model; + private ModelQuadHolder holder; + + @Test + public void anonymousTest() { + model = ModelFactory.createDefaultModel(); + + List tLst = new ArrayList(); + Resource s = ResourceFactory.createResource( "s" ); + Property p = ResourceFactory.createProperty( "p" ); + Resource o = ResourceFactory.createResource( "o" ); + tLst.add( new Triple( s.asNode(), p.asNode(), o.asNode() ) ); + model.add( s, p, o ); + + Resource s2 = ResourceFactory.createResource( "s2" ); + Property p2 = ResourceFactory.createProperty( "p2" ); + Resource o2 = ResourceFactory.createResource( "o2" ); + tLst.add( new Triple( s2.asNode(), p2.asNode(), o2.asNode() ) ); + model.add( s2, p2, o2 ); + + holder = new ModelQuadHolder( model ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + Quad q = new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)); + assertTrue( "missing "+q, lst.contains( q )); + + q = new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)); + assertTrue( "missing "+q, lst.contains( q )); + } + + @Test + public void namedTest() { + model = ModelFactory.createDefaultModel(); + + Node g = NodeFactory.createURI( "g" ); + List tLst = new ArrayList(); + Resource s = ResourceFactory.createResource( "s" ); + Property p = ResourceFactory.createProperty( "p" ); + Resource o = ResourceFactory.createResource( "o" ); + tLst.add( new Triple( s.asNode(), p.asNode(), o.asNode() ) ); + model.add( s, p, o ); + + Resource s2 = ResourceFactory.createResource( "s2" ); + Property p2 = ResourceFactory.createProperty( "p2" ); + Resource o2 = ResourceFactory.createResource( "o2" ); + tLst.add( new Triple( s2.asNode(), p2.asNode(), o2.asNode() ) ); + model.add( s2, p2, o2 ); + + holder = new ModelQuadHolder( g, model ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + Quad q = new Quad( g, tLst.get(0)); + assertTrue( "missing "+q, lst.contains( q )); + + q = new Quad( g, tLst.get(1)); + assertTrue( "missing "+q, lst.contains( q )); + } +} diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java new file mode 100644 index 00000000000..e071aa382cb --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java @@ -0,0 +1,202 @@ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.WhereBuilder; +import org.apache.jena.graph.Node; +import org.apache.jena.graph.NodeFactory; +import org.apache.jena.graph.Triple; +import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.Var; +import org.junit.Test; + +public class QBQuadHolderTest { + + private QBQuadHolder holder; + + + @Test + public void anonymousTest() + { + WhereBuilder builder = new WhereBuilder(); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + builder.addWhere( s, p, o ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + builder.addWhere( s2, p2, o2 ); + + holder = new QBQuadHolder( builder ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)), lst.get(1)); + } + + @Test + public void anonymousTest_Var() + { + WhereBuilder builder = new WhereBuilder(); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + builder.addWhere( s, p, o ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s, p2, o ) ); + tLst.add( new Triple( s2, p2, o2 ) ); + builder.addWhere( s2, p, o2 ); + + holder = new QBQuadHolder( builder ); + + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)), lst.get(1)); + } + + @Test + public void namedTest() + { + WhereBuilder builder = new WhereBuilder(); + + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + builder.addGraph( g, s, p, o ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + + builder.addGraph( g, s2, p2, o2 ); + + holder = new QBQuadHolder( builder ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void namedTest_Var() + { + WhereBuilder builder = new WhereBuilder(); + + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + builder.addGraph( g, s, p, o ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s, p2, o ) ); + tLst.add( new Triple( s2, p2, o2 ) ); + + builder.addGraph( g, s2, p, o2 ); + + holder = new QBQuadHolder( builder ); + + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + + @Test + public void mixedTest() + { + WhereBuilder builder = new WhereBuilder(); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + builder.addWhere( s, p, o ); + + Node g = NodeFactory.createURI( "g" ); + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + + builder.addGraph( g, s2, p2, o2 ); + + holder = new QBQuadHolder( builder ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void mixedTest_Var() + { + WhereBuilder builder = new WhereBuilder(); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + builder.addWhere( s, p, o ); + + Node g = NodeFactory.createURI( "g" ); + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s, p2, o ) ); + tLst.add( new Triple( s2, p2, o2 ) ); + + builder.addGraph( g, s2, p, o2 ); + + holder = new QBQuadHolder( builder ); + + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } +} diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java new file mode 100644 index 00000000000..4c170ea8379 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java @@ -0,0 +1,100 @@ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import static org.junit.Assert.assertEquals; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.graph.Node; +import org.apache.jena.graph.NodeFactory; +import org.apache.jena.graph.Triple; +import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.SingletonIterator; +import org.junit.Test; + +public class SingleQuadHolderTest { + + private SingleQuadHolder holder; + + @Test + public void getQuads_Quad() + { + Node g = NodeFactory.createURI( "g" ); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + Quad quad = new Quad( g, s, p, o ); + holder = new SingleQuadHolder( quad ); + List lst = holder.getQuads().toList(); + assertEquals( 1, lst.size() ); + assertEquals( quad, lst.get(0)); + } + + + @Test + public void getQuads_Quad_vars() + { + Node g = NodeFactory.createURI( "g" ); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + Quad quad = new Quad( g, s, p, o ); + holder = new SingleQuadHolder( quad ); + List lst = holder.getQuads().toList(); + assertEquals( 1, lst.size() ); + assertEquals( quad, lst.get(0)); + + Map map = new HashMap<>(); + Node p2 = NodeFactory.createURI( "p2" ); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + Quad quad2 = new Quad( g, s, p2, o ); + lst = holder.getQuads().toList(); + assertEquals( 1, lst.size() ); + assertEquals( quad2, lst.get(0)); + } + + @Test + public void getQuads_Triple() + { + + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + Triple triple = new Triple( s, p, o ); + Quad quad = new Quad( Quad.defaultGraphNodeGenerated, s, p, o ); + holder = new SingleQuadHolder( triple ); + List lst = holder.getQuads().toList(); + assertEquals( 1, lst.size() ); + assertEquals( quad, lst.get(0)); + } + + + @Test + public void getQuads_Triple_vars() + { + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + Triple triple = new Triple( s, p, o ); + Quad quad = new Quad( Quad.defaultGraphNodeGenerated, s, p, o ); + holder = new SingleQuadHolder( triple ); + List lst = holder.getQuads().toList(); + assertEquals( 1, lst.size() ); + assertEquals( quad, lst.get(0)); + + Map map = new HashMap<>(); + Node p2 = NodeFactory.createURI( "p2" ); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + Quad quad2 = new Quad( Quad.defaultGraphNodeGenerated, s, p2, o ); + lst = holder.getQuads().toList(); + assertEquals( 1, lst.size() ); + assertEquals( quad2, lst.get(0)); + } + +} diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java new file mode 100644 index 00000000000..a663339b246 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java @@ -0,0 +1,202 @@ +package org.apache.jena.arq.querybuilder.updatebuilder; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.WhereBuilder; +import org.apache.jena.arq.querybuilder.handlers.WhereHandler; +import org.apache.jena.graph.Node; +import org.apache.jena.graph.NodeFactory; +import org.apache.jena.graph.Triple; +import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.TriplePath; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.path.P_Link; +import org.apache.jena.sparql.path.Path; +import org.junit.Test; + +public class WhereQuadHolderTest { + + private WhereQuadHolder holder; + + + @Test + public void anonymousTest() + { + holder = new WhereQuadHolder( new PrefixHandler() ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + holder.addWhere( new TriplePath( s, new P_Link(p), o )); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + holder.addWhere( new TriplePath( s2, new P_Link(p2), o2 )); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)), lst.get(1)); + } + + @Test + public void anonymousTest_Var() + { + holder = new WhereQuadHolder( new PrefixHandler() ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + holder.addWhere( new TriplePath( s, new P_Link(p), o )); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s, p2, o ) ); + tLst.add( new Triple( s2, p2, o2 ) ); + holder.addWhere( new TriplePath( s2, new P_Link(p), o2 )); + + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(1)), lst.get(1)); + } + + @Test + public void namedTest() + { + holder = new WhereQuadHolder( new PrefixHandler() ); + + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + WhereHandler whereHandler = new WhereHandler(); + whereHandler.addWhere( new TriplePath(s, new P_Link(p), o )); + holder.addGraph( g, whereHandler ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + whereHandler = new WhereHandler(); + whereHandler.addWhere( new TriplePath(s2, new P_Link(p2), o2 )); + holder.addGraph( g, whereHandler ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void namedTest_Var() + { + holder = new WhereQuadHolder( new PrefixHandler() ); + + Node g = NodeFactory.createURI( "g" ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + WhereHandler whereHandler = new WhereHandler(); + whereHandler.addWhere( new TriplePath(s, new P_Link(p), o )); + holder.addGraph( g, whereHandler ); + + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + whereHandler = new WhereHandler(); + whereHandler.addWhere( new TriplePath(s2, new P_Link(p2), o2 )); + holder.addGraph( g, whereHandler ); + + tLst.add( new Triple( s, p2, o ) ); + tLst.add( new Triple( s2, p2, o2 ) ); + + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( g, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void mixedTest() + { + holder = new WhereQuadHolder( new PrefixHandler() ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createURI( "p" ); + Node o = NodeFactory.createURI( "o" ); + tLst.add( new Triple( s, p, o ) ); + holder.addWhere( new TriplePath(s, new P_Link(p), o ) ); + + Node g = NodeFactory.createURI( "g" ); + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s2, p2, o2 ) ); + WhereHandler whereHandler = new WhereHandler(); + whereHandler.addWhere( new TriplePath(s2, new P_Link(p2), o2 )); + holder.addGraph( g, whereHandler ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } + + @Test + public void mixedTest_Var() + { + holder = new WhereQuadHolder( new PrefixHandler() ); + + List tLst = new ArrayList(); + Node s = NodeFactory.createURI( "s" ); + Node p = NodeFactory.createVariable( "p" ); + Node o = NodeFactory.createURI( "o" ); + holder.addWhere( new TriplePath(s, new P_Link(p), o ) ); + + Node g = NodeFactory.createURI( "g" ); + Node s2 = NodeFactory.createURI( "s2" ); + Node p2 = NodeFactory.createURI( "p2" ); + Node o2 = NodeFactory.createURI( "o2" ); + tLst.add( new Triple( s, p2, o ) ); + tLst.add( new Triple( s2, p2, o2 ) ); + WhereHandler whereHandler = new WhereHandler(); + whereHandler.addWhere( new TriplePath(s2, new P_Link(p2), o2 )); + holder.addGraph( g, whereHandler ); + + Map map = new HashMap<>(); + map.put( Var.alloc(p), p2); + holder.setValues( map ); + + List lst = holder.getQuads().toList(); + assertEquals( 2, lst.size() ); + assertEquals( new Quad( Quad.defaultGraphNodeGenerated, tLst.get(0)), lst.get(0)); + assertEquals( new Quad( g, tLst.get(1)), lst.get(1)); + } +} diff --git a/jena-maven-tools/pom.xml b/jena-maven-tools/pom.xml index c3015881e84..7860c3e36d4 100644 --- a/jena-maven-tools/pom.xml +++ b/jena-maven-tools/pom.xml @@ -20,7 +20,6 @@ 4.0.0 jena-maven-tools maven-plugin - 3.7.0-SNAPSHOT Apache Jena - Maven Plugins, including schemagen Plugins for Apache Maven to perform source management activities, such as generating Java files from RDF vocabulary sources using @@ -30,7 +29,7 @@ org.apache.jena jena - 3.7.0-SNAPSHOT + 3.9.0-SNAPSHOT .. @@ -188,7 +187,7 @@ org.apache.jena jena-cmds - 3.7.0-SNAPSHOT + ${project.version} org.codehaus.plexus From 27691564775e52da291e3ae18c8b5989415ea9b8 Mon Sep 17 00:00:00 2001 From: Claude Warren Date: Sun, 7 Oct 2018 15:09:56 +0100 Subject: [PATCH 2/4] added license and removed dead code --- .../CollectionQuadHolderTest.java | 24 +++++++++++++------ .../updatebuilder/ModelQuadHolderTest.java | 18 +++++++++++++- .../updatebuilder/QBQuadHolderTest.java | 18 +++++++++++++- .../updatebuilder/SingleQuadHolderTest.java | 20 +++++++++++++--- .../updatebuilder/WhereQuadHolderTest.java | 20 +++++++++++++--- 5 files changed, 85 insertions(+), 15 deletions(-) diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java index d088f047aff..38be596ee5f 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/CollectionQuadHolderTest.java @@ -1,12 +1,26 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.apache.jena.arq.querybuilder.updatebuilder; import static org.junit.Assert.assertEquals; import java.util.ArrayList; -import java.util.Collection; import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; import java.util.List; import java.util.Map; @@ -15,8 +29,6 @@ import org.apache.jena.graph.Triple; import org.apache.jena.sparql.core.Quad; import org.apache.jena.sparql.core.Var; -import org.apache.jena.util.iterator.ExtendedIterator; -import org.apache.jena.util.iterator.WrappedIterator; import org.junit.Test; public class CollectionQuadHolderTest { @@ -138,7 +150,6 @@ public void namedGraphTest_Iterator_Var() @Test public void anonymousGraphTest_List() { - Node g = NodeFactory.createURI( "g" ); List tLst = new ArrayList(); Node s = NodeFactory.createURI( "s" ); @@ -192,7 +203,6 @@ public void anonymousGraphTest_List_Var() @Test public void anonymousGraphTest_Iterator() { - Node g = NodeFactory.createURI( "g" ); List tLst = new ArrayList(); Node s = NodeFactory.createURI( "s" ); diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java index 16a62044482..c061f966844 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/ModelQuadHolderTest.java @@ -1,3 +1,20 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.apache.jena.arq.querybuilder.updatebuilder; import static org.junit.Assert.assertEquals; @@ -12,7 +29,6 @@ import org.apache.jena.rdf.model.Model; import org.apache.jena.rdf.model.ModelFactory; import org.apache.jena.rdf.model.Property; -import org.apache.jena.rdf.model.RDFNode; import org.apache.jena.rdf.model.Resource; import org.apache.jena.rdf.model.ResourceFactory; import org.apache.jena.sparql.core.Quad; diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java index e071aa382cb..29398584862 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/QBQuadHolderTest.java @@ -1,3 +1,20 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.apache.jena.arq.querybuilder.updatebuilder; import static org.junit.Assert.assertEquals; @@ -7,7 +24,6 @@ import java.util.List; import java.util.Map; -import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; import org.apache.jena.arq.querybuilder.WhereBuilder; import org.apache.jena.graph.Node; import org.apache.jena.graph.NodeFactory; diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java index 4c170ea8379..81748d6bf89 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/SingleQuadHolderTest.java @@ -1,3 +1,20 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.apache.jena.arq.querybuilder.updatebuilder; import static org.junit.Assert.assertEquals; @@ -6,14 +23,11 @@ import java.util.List; import java.util.Map; -import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; import org.apache.jena.graph.Node; import org.apache.jena.graph.NodeFactory; import org.apache.jena.graph.Triple; import org.apache.jena.sparql.core.Quad; import org.apache.jena.sparql.core.Var; -import org.apache.jena.util.iterator.ExtendedIterator; -import org.apache.jena.util.iterator.SingletonIterator; import org.junit.Test; public class SingleQuadHolderTest { diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java index a663339b246..8ba810a0b39 100644 --- a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/updatebuilder/WhereQuadHolderTest.java @@ -1,3 +1,20 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.apache.jena.arq.querybuilder.updatebuilder; import static org.junit.Assert.assertEquals; @@ -7,8 +24,6 @@ import java.util.List; import java.util.Map; -import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; -import org.apache.jena.arq.querybuilder.WhereBuilder; import org.apache.jena.arq.querybuilder.handlers.WhereHandler; import org.apache.jena.graph.Node; import org.apache.jena.graph.NodeFactory; @@ -17,7 +32,6 @@ import org.apache.jena.sparql.core.TriplePath; import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.path.P_Link; -import org.apache.jena.sparql.path.Path; import org.junit.Test; public class WhereQuadHolderTest { From bb9c99950c3b27c47e26978ac0cdea417822b41c Mon Sep 17 00:00:00 2001 From: Claude Warren Date: Fri, 12 Oct 2018 21:25:36 +0100 Subject: [PATCH 3/4] removed .gitignore accidentally checked in. --- jena-extras/jena-querybuilder/.gitignore | 1 - 1 file changed, 1 deletion(-) delete mode 100644 jena-extras/jena-querybuilder/.gitignore diff --git a/jena-extras/jena-querybuilder/.gitignore b/jena-extras/jena-querybuilder/.gitignore deleted file mode 100644 index d86b3dbb07d..00000000000 --- a/jena-extras/jena-querybuilder/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/.project_old From 24a092d9ea4633219aa3932daedb3e728af51051 Mon Sep 17 00:00:00 2001 From: Claude Warren Date: Fri, 12 Oct 2018 21:46:24 +0100 Subject: [PATCH 4/4] reversing unintended changes --- jena-maven-tools/pom.xml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/jena-maven-tools/pom.xml b/jena-maven-tools/pom.xml index 7860c3e36d4..c3015881e84 100644 --- a/jena-maven-tools/pom.xml +++ b/jena-maven-tools/pom.xml @@ -20,6 +20,7 @@ 4.0.0 jena-maven-tools maven-plugin + 3.7.0-SNAPSHOT Apache Jena - Maven Plugins, including schemagen Plugins for Apache Maven to perform source management activities, such as generating Java files from RDF vocabulary sources using @@ -29,7 +30,7 @@ org.apache.jena jena - 3.9.0-SNAPSHOT + 3.7.0-SNAPSHOT .. @@ -187,7 +188,7 @@ org.apache.jena jena-cmds - ${project.version} + 3.7.0-SNAPSHOT org.codehaus.plexus