use of org.openrdf.model.URI in project stanbol by apache.
the class ResourceAdapterTest method testFloat.
@Test
public void testFloat() {
Model graph = new TreeModel();
URI id = vf.createURI("http://www.example.org/test");
URI floatTestField = vf.createURI("http://www.example.org/field/float");
graph.add(id, floatTestField, vf.createLiteral(Float.NaN));
graph.add(id, floatTestField, vf.createLiteral(Float.POSITIVE_INFINITY));
graph.add(id, floatTestField, vf.createLiteral(Float.NEGATIVE_INFINITY));
RdfValueFactory valueFactory = new RdfValueFactory(graph, vf);
Representation r = valueFactory.createRepresentation(id.stringValue());
Set<Float> expected = new HashSet<Float>(Arrays.asList(Float.NaN, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
Iterator<Float> dit = r.get(floatTestField.stringValue(), Float.class);
while (dit.hasNext()) {
Float val = dit.next();
Assert.assertNotNull(val);
Assert.assertTrue(expected.remove(val));
}
Assert.assertTrue(expected.isEmpty());
}
use of org.openrdf.model.URI in project stanbol by apache.
the class ResourceAdapterTest method testDouble.
/**
* Test related to STANBOL-698
*/
@Test
public void testDouble() {
Model graph = new TreeModel();
URI id = vf.createURI("http://www.example.org/test");
URI doubleTestField = vf.createURI("http://www.example.org/field/double");
graph.add(id, doubleTestField, vf.createLiteral(Double.NaN));
graph.add(id, doubleTestField, vf.createLiteral(Double.POSITIVE_INFINITY));
graph.add(id, doubleTestField, vf.createLiteral(Double.NEGATIVE_INFINITY));
RdfValueFactory valueFactory = new RdfValueFactory(graph, vf);
Representation r = valueFactory.createRepresentation(id.stringValue());
Set<Double> expected = new HashSet<Double>(Arrays.asList(Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY));
Iterator<Double> dit = r.get(doubleTestField.stringValue(), Double.class);
while (dit.hasNext()) {
Double val = dit.next();
Assert.assertNotNull(val);
Assert.assertTrue(expected.remove(val));
}
Assert.assertTrue(expected.isEmpty());
}
use of org.openrdf.model.URI in project stanbol by apache.
the class SesameModelWriter method toRDF.
private Model toRDF(QueryResultList<?> resultList) {
final Model resultGraph;
Class<?> type = resultList.getType();
if (String.class.isAssignableFrom(type)) {
//create a new ImmutableGraph
resultGraph = new LinkedHashModel();
for (Object result : resultList) {
//add a triple to each reference in the result set
resultGraph.add(QUERY_RESULT_LIST, QUERY_RESULT, sesameFactory.createURI(result.toString()));
}
} else {
//first determine the type of the resultList
final boolean isSignType;
if (Representation.class.isAssignableFrom(type)) {
isSignType = false;
} else if (Representation.class.isAssignableFrom(type)) {
isSignType = true;
} else {
//incompatible type -> throw an Exception
throw new IllegalArgumentException("Parsed type " + type + " is not supported");
}
//special treatment for RdfQueryResultList for increased performance
if (resultList instanceof SesameQueryResultList) {
resultGraph = ((SesameQueryResultList) resultList).getModel();
if (isSignType) {
//if we build a ResultList for Signs, we need to do more things
//first remove all triples representing results
resultGraph.filter(null, QUERY_RESULT, null).clear();
//to the Sign IDs
for (Object result : resultList) {
URI signId = sesameFactory.createURI(((Entity) result).getId());
addEntityTriplesToGraph(resultGraph, (Entity) result);
resultGraph.add(QUERY_RESULT_LIST, QUERY_RESULT, signId);
}
}
} else {
//any other implementation of the QueryResultList interface
//create a new graph
resultGraph = new LinkedHashModel();
if (Representation.class.isAssignableFrom(type)) {
for (Object result : resultList) {
URI resultId;
if (!isSignType) {
addRDFTo(resultGraph, (Representation) result);
resultId = sesameFactory.createURI(((Representation) result).getId());
} else {
addRDFTo(resultGraph, (Entity) result);
resultId = sesameFactory.createURI(((Entity) result).getId());
}
//Note: In case of Representation this Triple points to
// the representation. In case of Signs it points to
// the sign.
resultGraph.add(QUERY_RESULT_LIST, QUERY_RESULT, resultId);
}
}
}
}
return resultGraph;
}
use of org.openrdf.model.URI in project stanbol by apache.
the class SesameYardTest method testBNodeSupport.
@Test
public void testBNodeSupport() throws YardException, RepositoryException {
RepositoryConnection con = repo.getConnection();
org.openrdf.model.ValueFactory sesameFactory = con.getValueFactory();
URI subject = sesameFactory.createURI("urn:test.sesameyard:bnodesupport.subject");
URI property = sesameFactory.createURI("urn:test.sesameyard:bnodesupport.property");
URI value = sesameFactory.createURI("urn:test.sesameyard:bnodesupport.value");
URI property2 = sesameFactory.createURI("urn:test.sesameyard:bnodesupport.property2");
URI loop1 = sesameFactory.createURI("urn:test.sesameyard:bnodesupport.loop1");
URI loop2 = sesameFactory.createURI("urn:test.sesameyard:bnodesupport.loop2");
BNode bnode1 = sesameFactory.createBNode();
BNode bnode2 = sesameFactory.createBNode();
con.add(subject, property, bnode1);
con.add(bnode1, property2, value);
con.add(bnode1, loop1, bnode2);
con.add(bnode2, loop2, bnode1);
con.commit();
con.close();
Yard yard = getYard();
Representation rep = yard.getRepresentation(subject.stringValue());
Assert.assertTrue(rep instanceof RdfRepresentation);
Model model = ((RdfRepresentation) rep).getModel();
//Assert for the indirect statements to be present in the model
Assert.assertFalse(model.filter(null, property2, null).isEmpty());
Assert.assertFalse(model.filter(null, loop1, null).isEmpty());
Assert.assertFalse(model.filter(null, loop2, null).isEmpty());
}
use of org.openrdf.model.URI in project stanbol by apache.
the class SesameYard method find.
@Override
public final QueryResultList<Representation> find(FieldQuery parsedQuery) throws YardException, IllegalArgumentException {
if (parsedQuery == null) {
throw new IllegalArgumentException("The parsed query MUST NOT be NULL!");
}
final SparqlFieldQuery query = SparqlFieldQueryFactory.getSparqlFieldQuery(parsedQuery);
RepositoryConnection con = null;
TupleQueryResult results = null;
try {
con = repository.getConnection();
con.begin();
//execute the query
int limit = QueryUtils.getLimit(query, getConfig().getDefaultQueryResultNumber(), getConfig().getMaxQueryResultNumber());
results = executeSparqlFieldQuery(con, query, limit, true);
//parse the results and generate the Representations
//create an own valueFactors so that all the data of the query results
//are added to the same Sesame Model
Model model = new TreeModel();
RdfValueFactory valueFactory = new RdfValueFactory(model, sesameFactory);
List<Representation> representations = limit > 0 ? new ArrayList<Representation>(limit) : new ArrayList<Representation>();
Map<String, URI> bindings = new HashMap<String, URI>(query.getFieldVariableMappings().size());
for (Entry<String, String> mapping : query.getFieldVariableMappings().entrySet()) {
bindings.put(mapping.getValue(), sesameFactory.createURI(mapping.getKey()));
}
while (results.hasNext()) {
BindingSet result = results.next();
Value value = result.getValue(query.getRootVariableName());
if (value instanceof URI) {
URI subject = (URI) value;
//link the result with the query result
model.add(queryRoot, queryResult, subject);
//now copy over the other selected data
for (String binding : result.getBindingNames()) {
URI property = bindings.get(binding);
if (property != null) {
model.add(subject, property, result.getValue(binding));
}
//else no mapping for the query.getRootVariableName()
}
//create a representation and add it to the results
representations.add(valueFactory.createRdfRepresentation(subject));
}
//ignore non URI results
}
con.commit();
return new SesameQueryResultList(model, query, representations);
} catch (RepositoryException e) {
throw new YardException("Unable to execute findReferences query", e);
} catch (QueryEvaluationException e) {
throw new YardException("Unable to execute findReferences query", e);
} finally {
if (results != null) {
//close the result if present
try {
results.close();
} catch (QueryEvaluationException ignore) {
/* ignore */
}
}
if (con != null) {
try {
con.close();
} catch (RepositoryException ignore) {
/* ignore */
}
}
}
}
Aggregations