Skip to content

Commit

Permalink
more work
Browse files Browse the repository at this point in the history
  • Loading branch information
Aklakan committed Oct 27, 2021
1 parent 1a11b9b commit 4ea4903
Show file tree
Hide file tree
Showing 7 changed files with 257 additions and 23 deletions.
Expand Up @@ -21,6 +21,14 @@ public static ResultSet toResultSet(Table table) {
return ResultSet.adapt(table.toRowSet());
}

public static Table createTable(List<Var> vars, Iterable<Binding> bindings) {
Table result = TableFactory.create(vars);
for (Binding b : bindings) {
result.addBinding(b);
}
return result;
}

public static Table createTable(RowSet rs) {
List<Var> vars = rs.getResultVars();
Table result = TableFactory.create(vars);
Expand All @@ -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<Var> oldVars = table.getVars();

List<Var> newVars = new ArrayList<Var>(oldVars.size());
Expand Down
@@ -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<Binding> toMultiset(ResultSet rs) {
Multiset<Binding> 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<Binding> compareOrdered(ResultSet a, ResultSet b) {
ListDiff<Binding> 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<Binding> compareUnordered(ResultSet a, ResultSet b) {
ListDiff<Binding> result = new ListDiff<>();

Multiset<Binding> x = toMultiset(a);
Multiset<Binding> y = toMultiset(b);

Multiset<Binding> common = HashMultiset.create(Multisets.intersection(x, y));

y.removeAll(common);
x.removeAll(common);

result.getAdded().addAll(y);
result.getRemoved().addAll(x);

return result;
}


}
@@ -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<Model>
{
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;
}
}
@@ -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;
Expand Down
Expand Up @@ -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;
Expand All @@ -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;
Expand Down Expand Up @@ -69,14 +71,14 @@ public static ModelDiff compareModel(Model a, Model b) {
private Query query = null;
private String queryString;

private Diff<ResultSetPart> resultSetDiff = null; // The diff after the query execution
private Diff<Table> resultSetDiff = null; // The diff after the query execution
private ModelDiff modelDiff = null;
private Diff<Boolean> 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) {
Expand Down Expand Up @@ -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.<ResultSetPart>create(new ResultSetPart(), new ResultSetPart()); //new ListDiff<>();
resultSetDiff = Diff.<Table>create(TableFactory.createEmpty(), TableFactory.createEmpty()); //new ListDiff<>();
throw new RuntimeException(e);
}



ListDiff<Binding> 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();
Expand All @@ -208,16 +210,13 @@ public void log(long added, long removed) {
}


public void log(ResultSetPart ra, ResultSetPart rb) {
List<Binding> a = ra.getBindings();
List<Binding> 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));
Expand Down Expand Up @@ -491,6 +490,11 @@ public Iterator<JsonObject> execJsonItems() {
throw new RuntimeException("Not implemented yet");
}

@Override
public String getQueryString() {
return null;
}


/*
@Override
Expand Down
Expand Up @@ -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;

Expand Down
Expand Up @@ -194,13 +194,13 @@ public Diff<Set<Quad>> apply(Diff<Set<Quad>> input) {
}

public static UpdateProcessor executeInsertTriples(UpdateExecutionFactory uef, Iterable<Triple> triples) {
Iterable<Quad> quads = Iterables.transform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated);
Iterable<Quad> quads = Iterables.applyNodeTransform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated);
UpdateProcessor result = executeInsertQuads(uef, quads);
return result;
}

public static UpdateProcessor executeDeleteTriples(UpdateExecutionFactory uef, Iterable<Triple> triples) {
Iterable<Quad> quads = Iterables.transform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated);
Iterable<Quad> quads = Iterables.applyNodeTransform(triples, FN_QuadFromTriple.fnDefaultGraphNodeGenerated);
UpdateProcessor result = executeDeleteQuads(uef, quads);
return result;
}
Expand Down

0 comments on commit 4ea4903

Please sign in to comment.