org.aksw.jena_sparql_api.utils.ResultSetUtils Maven / Gradle / Ivy
The newest version!
package org.aksw.jena_sparql_api.utils;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.aksw.commons.collections.diff.ListDiff;
import org.aksw.jena_sparql_api.utils.model.QuerySolutionWithEquals;
import org.apache.jena.graph.Node;
import org.apache.jena.query.QueryExecution;
import org.apache.jena.query.QuerySolution;
import org.apache.jena.query.ResultSet;
import org.apache.jena.query.ResultSetFactory;
import org.apache.jena.rdf.model.RDFNode;
import org.apache.jena.sparql.algebra.Table;
import org.apache.jena.sparql.algebra.TableFactory;
import org.apache.jena.sparql.core.Var;
import org.apache.jena.sparql.engine.QueryIterator;
import org.apache.jena.sparql.engine.binding.Binding;
import org.apache.jena.sparql.engine.binding.BindingFactory;
import org.apache.jena.sparql.engine.iterator.QueryIterPlainWrapper;
import org.apache.jena.sparql.expr.NodeValue;
import org.apache.jena.util.iterator.ExtendedIterator;
import org.apache.jena.util.iterator.WrappedIterator;
import com.google.common.collect.HashMultiset;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multisets;
public class ResultSetUtils {
/** Materialize a {@link ResultSet} into a {@link Table} */
public static Table resultSetToTable(ResultSet rs) {
List vars = Var.varList(rs.getResultVars());
Table result = TableFactory.create(vars);
while (rs.hasNext()) {
Binding b = BindingFactory.copy(rs.nextBinding());
result.addBinding(b);
}
return result;
}
public static Multiset toMultisetQs(ResultSet rs) {
Multiset result = HashMultiset.create();
while(rs.hasNext()) {
QuerySolution original = rs.next();
QuerySolution wrapped = new QuerySolutionWithEquals(original);
result.add(wrapped);
}
return result;
}
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;
}
public static List getVars(ResultSet rs) {
List result = VarUtils.toList(rs.getResultVars());
return result;
}
public static Node getNextNode(ResultSet rs, Var v) {
Node result = null;
if (rs.hasNext()) {
Binding binding = rs.nextBinding();
result = binding.get(v);
}
return result;
}
public static Optional tryGetNextNode(ResultSet rs, Var v) {
Node node = getNextNode(rs, v);
Optional result = Optional.ofNullable(node);
return result;
}
public static RDFNode getNextRDFNode(ResultSet rs, Var v) {
RDFNode result = null;
if (rs.hasNext()) {
QuerySolution qs = rs.next();
String varName = v.getName();
result = qs.get(varName);
}
return result;
}
public static Optional tryGetNextRDFNode(ResultSet rs, Var v) {
RDFNode node = getNextRDFNode(rs, v);
Optional result = Optional.ofNullable(node);
return result;
}
public static Integer resultSetToInt(ResultSet rs, Var v) {
Integer result = null;
if (rs.hasNext()) {
Binding binding = rs.nextBinding();
Node node = binding.get(v);
NodeValue nv = NodeValue.makeNode(node);
result = nv.getInteger().intValue();
// TODO Validate that the result actually is int.
//result = node.getLiteral().
}
return result;
}
// public static Long resultSetToInt(ResultSet rs, Var v) {
// Integer result = null;
//
// if (rs.hasNext()) {
// Binding binding = rs.nextBinding();
//
// Node node = binding.get(v);
// NodeValue nv = NodeValue.makeNode(node);
// result = nv.getInteger().longValue();
//
// // TODO Validate that the result actually is int.
// //result = node.getLiteral().
// }
//
// return result;
// }
public static List resultSetToList(ResultSet rs, Var v) {
List result = new ArrayList();
while (rs.hasNext()) {
Binding binding = rs.nextBinding();
Node node = binding.get(v);
result.add(node);
}
return result;
}
public static Map partition(ResultSet rs, Var var) {
List varNames = rs.getResultVars();
Map result = new LinkedHashMap();
while(rs.hasNext()) {
Binding binding = rs.nextBinding();
Node node = binding.get(var);
ResultSetPart rsp = result.get(node);
if(rsp == null) {
rsp = new ResultSetPart(varNames);
result.put(node, rsp);
}
rsp.getBindings().add(binding);
}
return result;
}
public static ExtendedIterator toIteratorBinding(QueryExecution qe) {
ResultSet rs = qe.execSelect();
ExtendedIterator result = toIteratorBinding(rs, qe);
return result;
}
/**
* This version returns an iterator capable of closing the corresponding query execution
*
* @param rs
* @param qe
* @return
*/
public static ExtendedIterator toIteratorBinding(ResultSet rs, QueryExecution qe) {
Iterator it = new IteratorResultSetBinding(rs);
Closeable closeable = new CloseableQueryExecution(qe);
Iterator tmp = new IteratorClosable(it, closeable);
ExtendedIterator result = WrappedIterator.create(tmp);
return result;
}
public static Iterator toIteratorBinding(ResultSet rs) {
Iterator result = new IteratorResultSetBinding(rs);
return result;
}
public static Multimap, Binding> index(ResultSet rs, List vars) {
Multimap, Binding> result = LinkedListMultimap.create();
while(rs.hasNext()) {
Binding binding = rs.nextBinding();
List key = new ArrayList(vars.size());
for(Var var : vars) {
Node node = binding.get(var);
key.add(node);
}
result.put(key, binding);
}
return result;
}
public static ResultSet join(ResultSet a, ResultSet b) {
//Set aVarNames = new HashSet(a.getResultVars());
List aVarNames = a.getResultVars();
Set joinVarNames = new HashSet(aVarNames);
joinVarNames.retainAll(b.getResultVars());
List bVarsOnly = new ArrayList(b.getResultVars());
bVarsOnly.removeAll(joinVarNames);
List allVars = new ArrayList(aVarNames);
allVars.addAll(bVarsOnly);
List joinVars = VarUtils.toList(joinVarNames);
Multimap, Binding> ma = index(a, joinVars);
Multimap, Binding> mb = index(b, joinVars);
Set> keys = new HashSet>(ma.keySet());
keys.retainAll(mb.keySet());
// Clean up unused keys
ma.keySet().retainAll(keys);
mb.keySet().retainAll(keys);
Iterator joinIterator = new IteratorJoin>(keys.iterator(), ma, mb);
QueryIterator queryIter = new QueryIterPlainWrapper(joinIterator);
ResultSet result = ResultSetFactory.create(queryIter, allVars);
return result;
}
public static ResultSet project(ResultSet rs, Iterable vars, boolean uniq) {
Collection newBindings = uniq
? new HashSet()
: new ArrayList()
;
while(rs.hasNext()) {
Binding o = rs.nextBinding();
Binding n = BindingUtils.project(o, vars);
newBindings.add(n);
}
ResultSet result = create2(vars, newBindings.iterator());
return result;
}
public static ResultSet create(List varNames, Iterator bindingIt) {
QueryIterator queryIter = new QueryIterPlainWrapper(bindingIt);
ResultSet result = ResultSetFactory.create(queryIter, varNames);
return result;
}
public static ResultSet create2(Iterable vars, Iterator bindingIt) {
List varNames = org.aksw.jena_sparql_api.utils.VarUtils.getVarNames(vars);
ResultSet result = create(varNames, bindingIt);
return result;
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy