diff --git a/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/binding/TableUtils.java b/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/binding/TableUtils.java index 5083a0e60..eda52cf5a 100644 --- a/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/binding/TableUtils.java +++ b/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/binding/TableUtils.java @@ -21,6 +21,14 @@ public static ResultSet toResultSet(Table table) { return ResultSet.adapt(table.toRowSet()); } + public static Table createTable(List vars, Iterable bindings) { + Table result = TableFactory.create(vars); + for (Binding b : bindings) { + result.addBinding(b); + } + return result; + } + public static Table createTable(RowSet rs) { List vars = rs.getResultVars(); Table result = TableFactory.create(vars); @@ -42,7 +50,7 @@ public static Table createTable(ResultSet rs) { } - public static Table transform(Table table, NodeTransform transform) { + public static Table applyNodeTransform(Table table, NodeTransform transform) { List oldVars = table.getVars(); List newVars = new ArrayList(oldVars.size()); diff --git a/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/execution/ResultSetCompareUtils.java b/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/execution/ResultSetCompareUtils.java new file mode 100644 index 000000000..10b1db951 --- /dev/null +++ b/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/execution/ResultSetCompareUtils.java @@ -0,0 +1,103 @@ +package org.aksw.jenax.arq.util.execution; + +import org.aksw.commons.collections.diff.ListDiff; +import org.apache.jena.query.ResultSet; +import org.apache.jena.sparql.engine.binding.Binding; + +import com.google.common.collect.HashMultiset; +import com.google.common.collect.Multiset; +import com.google.common.collect.Multisets; + +public class ResultSetCompareUtils { + + public static Multiset toMultiset(ResultSet rs) { + Multiset result = HashMultiset.create(); + while(rs.hasNext()) { + Binding original = rs.nextBinding(); + + Binding wrapped = original; + //QuerySolution wrapped = new QuerySolutionWithEquals(original); + + result.add(wrapped); + } + + return result; + } + + /** + * Traverse the resultset in order, and write out the missing items on each side: + * 1 2 + * --- + * a a + * b c + * d d + * + * gives: + * [c] [b] + * + * (1 lacks c, 2 lacks b) + * + * + * @param a + * @param b + * @return + */ + public static ListDiff compareOrdered(ResultSet a, ResultSet b) { + ListDiff result = new ListDiff<>(); + + Binding x = null; + Binding y = null; + + while(a.hasNext()) { + if(!b.hasNext()) { + while(a.hasNext()) { + result.getAdded().add(a.nextBinding()); + } + return result; + } + + //if((x == null && y == null) || x.equals(y) + if(x == y || x.equals(y)) { + x = a.nextBinding(); + y = b.nextBinding(); + continue; + } + + String sx = x.toString(); + String sy = y.toString(); + + if(sx.compareTo(sy) < 0) { + result.getRemoved().add(x); + x = a.nextBinding(); + } else { + result.getAdded().add(y); + y = b.nextBinding(); + } + } + + while(b.hasNext()) { + result.getRemoved().add(b.nextBinding()); + } + + return result; + } + + public static ListDiff compareUnordered(ResultSet a, ResultSet b) { + ListDiff result = new ListDiff<>(); + + Multiset x = toMultiset(a); + Multiset y = toMultiset(b); + + Multiset common = HashMultiset.create(Multisets.intersection(x, y)); + + y.removeAll(common); + x.removeAll(common); + + result.getAdded().addAll(y); + result.getRemoved().addAll(x); + + return result; + } + + +} diff --git a/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/triple/ModelDiff.java b/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/triple/ModelDiff.java new file mode 100644 index 000000000..cc5ded086 --- /dev/null +++ b/jenax-arq-parent/jenax-arq-utils/src/main/java/org/aksw/jenax/arq/util/triple/ModelDiff.java @@ -0,0 +1,118 @@ +package org.aksw.jenax.arq.util.triple; + +import org.aksw.commons.collections.diff.Diff; + +import org.apache.jena.rdf.model.Model; +import org.apache.jena.rdf.model.ModelFactory; +import org.apache.jena.rdf.model.Statement; + +/** + * @author Claus Stadler + * + * Date: 7/12/11 + * Time: 10:54 PM + */ +public class ModelDiff + extends Diff +{ + public ModelDiff() { + super( + ModelFactory.createDefaultModel(), + ModelFactory.createDefaultModel(), + ModelFactory.createDefaultModel()); + } + + public ModelDiff(Model added, Model removed, Model retained) { + super(added, removed,retained); + } + + /** + * Basically adds a statement to the set of added items. + * However, if the statement is marked as removed, it is + * removed from the removal-set, but not added to added-set. + * + * @param stmt + */ + public void add(Statement stmt) { + if(getRemoved().contains(stmt)) { + getRemoved().remove(stmt); + } else { + getRemoved().remove(stmt); + getAdded().add(stmt); + } + } + + + /** + * Adds an item to the set of removed items, unless an equal statement is + * contained in the added-set. In this case the statement is removed from the + * added set. + * + * @param stmt + */ + public void remove(Statement stmt) { + getAdded().remove(stmt); + getRemoved().add(stmt); + } + + public void add(Model model) { + for(Statement stmt : model.listStatements().toList()) { + add(stmt); + } + } + + public void remove(Model model) { + for(Statement stmt : model.listStatements().toList()) { + remove(stmt); + } + } + + public void clear() { + getAdded().removeAll(); + getRemoved().removeAll(); + } + + + public boolean isEmpty() { + boolean result = getAdded().isEmpty() && getRemoved().isEmpty(); + return result; + } + + /* + public void add(Statement stmt) { + getRemoved().remove(stmt); + getAdded().add(stmt); + } + + public void remove(Statement stmt) { + getAdded().remove(stmt); + getRemoved().add(stmt); + } + + public void add(Model model) { + getRemoved().remove(model); + getAdded().add(model); + } + + public void remove(Model model) { + getAdded().remove(model); + getRemoved().add(model); + } + + public void clear() { + getAdded().removeAll(); + getRemoved().removeAll(); + }*/ + + public static ModelDiff create(Model a, Model b) { + ModelDiff result = new ModelDiff(); + + result.getAdded().add(b); + result.getAdded().remove(a); + + result.getRemoved().add(a); + result.getRemoved().remove(b); + + return result; + } +} diff --git a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/changeset/SinkChangeSetWriter.java b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/changeset/SinkChangeSetWriter.java index f19961bde..ce63d3326 100644 --- a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/changeset/SinkChangeSetWriter.java +++ b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/changeset/SinkChangeSetWriter.java @@ -1,9 +1,9 @@ package org.aksw.jena_sparql_api.changeset; import org.aksw.commons.collections.diff.Diff; -import org.aksw.jena_sparql_api.core.SparqlService; import org.aksw.jenax.arq.connection.core.QueryExecutionFactory; import org.aksw.jenax.arq.connection.core.UpdateExecutionFactory; +import org.aksw.jenax.connectionless.SparqlService; import org.apache.jena.atlas.lib.Sink; import org.apache.jena.sparql.core.Quad; import org.apache.jena.update.UpdateProcessor; diff --git a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionCompare.java b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionCompare.java index 353342a16..06d45bd56 100644 --- a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionCompare.java +++ b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionCompare.java @@ -2,15 +2,14 @@ import java.io.ByteArrayOutputStream; import java.util.Iterator; -import java.util.List; import java.util.concurrent.TimeUnit; import org.aksw.commons.collections.diff.Diff; import org.aksw.commons.collections.diff.ListDiff; import org.aksw.commons.util.string.StringUtils; -import org.aksw.jena_sparql_api.core.utils.ResultSetUtils; -import org.aksw.jena_sparql_api.utils.ModelDiff; -import org.aksw.jena_sparql_api.utils.ResultSetPart; +import org.aksw.jenax.arq.util.binding.TableUtils; +import org.aksw.jenax.arq.util.execution.ResultSetCompareUtils; +import org.aksw.jenax.arq.util.triple.ModelDiff; import org.apache.jena.atlas.json.JsonArray; import org.apache.jena.atlas.json.JsonObject; import org.apache.jena.graph.Node; @@ -27,7 +26,10 @@ import org.apache.jena.rdf.model.ModelFactory; import org.apache.jena.riot.RDFDataMgr; import org.apache.jena.riot.RDFFormat; +import org.apache.jena.sparql.algebra.Table; +import org.apache.jena.sparql.algebra.TableFactory; import org.apache.jena.sparql.core.Quad; +import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.util.Context; import org.slf4j.Logger; @@ -69,14 +71,14 @@ public static ModelDiff compareModel(Model a, Model b) { private Query query = null; private String queryString; - private Diff resultSetDiff = null; // The diff after the query execution + private Diff resultSetDiff = null; // The diff after the query execution private ModelDiff modelDiff = null; private Diff askDiff = null; public boolean isDifference() { if(resultSetDiff != null) { - return !(resultSetDiff.getAdded().getBindings().isEmpty() && resultSetDiff.getRemoved().getBindings().isEmpty()); + return !(resultSetDiff.getAdded().isEmpty() && resultSetDiff.getRemoved().isEmpty()); } else if(modelDiff != null) { return !(modelDiff.getAdded().isEmpty() && modelDiff.getRemoved().isEmpty()); } else if(askDiff != null) { @@ -172,19 +174,19 @@ public ResultSet execSelect() { timeB = bsw.stop().elapsed(TimeUnit.MILLISECONDS); } catch(RuntimeException e) { // Set diff in order to indicate that the execution was performed - resultSetDiff = Diff.create(new ResultSetPart(), new ResultSetPart()); //new ListDiff<>(); + resultSetDiff = Diff.
create(TableFactory.createEmpty(), TableFactory.createEmpty()); //new ListDiff<>(); throw new RuntimeException(e); } ListDiff tmp = (isOrdered) - ? ResultSetUtils.compareOrdered(x, y) - : ResultSetUtils.compareUnordered(x, y); + ? ResultSetCompareUtils.compareOrdered(x, y) + : ResultSetCompareUtils.compareUnordered(x, y); resultSetDiff = Diff.create( - new ResultSetPart(x.getResultVars(), tmp.getAdded()), - new ResultSetPart(y.getResultVars(), tmp.getRemoved())); + TableUtils.createTable(Var.varList(x.getResultVars()), tmp.getAdded()), + TableUtils.createTable(Var.varList(y.getResultVars()), tmp.getRemoved())); // Reset x once more in order to return it x.reset(); @@ -208,16 +210,13 @@ public void log(long added, long removed) { } - public void log(ResultSetPart ra, ResultSetPart rb) { - List a = ra.getBindings(); - List b = rb.getBindings(); - - log(a.size(), b.size()); - boolean isEqual = a.isEmpty() && b.isEmpty(); + public void log(Table ra, Table rb) { + log(ra.size(), rb.size()); + boolean isEqual = ra.isEmpty() && rb.isEmpty(); if(!isEqual) { - ResultSet rsa = ResultSetPart.toResultSet(ra); - ResultSet rsb = ResultSetPart.toResultSet(rb); + ResultSet rsa = TableUtils.toResultSet(ra); + ResultSet rsb = TableUtils.toResultSet(rb); logger.debug("Differences detected for query: \n" + queryString); logger.debug("Excessive:\n" + ResultSetFormatter.asText(rsa)); @@ -491,6 +490,11 @@ public Iterator execJsonItems() { throw new RuntimeException("Not implemented yet"); } + @Override + public String getQueryString() { + return null; + } + /* @Override diff --git a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionFactoryCompare.java b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionFactoryCompare.java index ffa4f9a55..854c59a28 100644 --- a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionFactoryCompare.java +++ b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/compare/QueryExecutionFactoryCompare.java @@ -2,6 +2,7 @@ import org.aksw.jena_sparql_api.core.QueryExecutionFactoryBackQuery; +import org.aksw.jenax.arq.connection.core.QueryExecutionFactory; import org.apache.jena.query.Query; import org.apache.jena.query.QueryExecution; diff --git a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/core/utils/UpdateExecutionUtils.java b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/core/utils/UpdateExecutionUtils.java index 6139335f7..c44f6da4b 100644 --- a/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/core/utils/UpdateExecutionUtils.java +++ b/jenax-rx-parent/jenax-rx-dataaccess/src/main/java/org/aksw/jena_sparql_api/core/utils/UpdateExecutionUtils.java @@ -194,13 +194,13 @@ public Diff> apply(Diff> input) { } public static UpdateProcessor executeInsertTriples(UpdateExecutionFactory uef, Iterable triples) { - Iterable quads = Iterables.transform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated); + Iterable quads = Iterables.applyNodeTransform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated); UpdateProcessor result = executeInsertQuads(uef, quads); return result; } public static UpdateProcessor executeDeleteTriples(UpdateExecutionFactory uef, Iterable triples) { - Iterable quads = Iterables.transform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated); + Iterable quads = Iterables.applyNodeTransform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated); UpdateProcessor result = executeDeleteQuads(uef, quads); return result; }