protected static Resource _processProperty( String propertyID, NativeObject propertyNO, String baseURL, SailConnection sailConnection) throws SailException { String label = _getStringProperty(propertyNO, "label"); String pluralLabel = _getStringProperty(propertyNO, "pluralLabel"); String uri = _getStringProperty(propertyNO, "uri"); String valueType = _getStringProperty(propertyNO, "valueType"); if (label == null) { label = propertyID; } if (pluralLabel == null) { pluralLabel = label; } if (valueType == null) { valueType = "item"; } Resource resource; try { resource = new URIImpl(uri); } catch (Exception e) { uri = baseURL + _encode(propertyID); resource = new URIImpl(uri); } sailConnection.addStatement(resource, RDF.TYPE, RDF.PROPERTY); sailConnection.addStatement(resource, ExhibitOntology.ID, new LiteralImpl(propertyID)); sailConnection.addStatement(resource, RDFS.LABEL, new LiteralImpl(label)); sailConnection.addStatement( resource, ExhibitOntology.PLURAL_LABEL, new LiteralImpl(pluralLabel)); sailConnection.addStatement(resource, ExhibitOntology.VALUE_TYPE, new LiteralImpl(valueType)); return resource; }
@Override public void remove(Iterable<Statement> triples, String namedGraphURI) { for (Statement stmt : triples) try { if (namedGraphURI == null) { connection.removeStatements(stmt.getSubject(), stmt.getPredicate(), stmt.getObject()); } else { connection.removeStatements( stmt.getSubject(), stmt.getPredicate(), stmt.getObject(), new ValueFactoryImpl().createURI(namedGraphURI)); } } catch (SailException e) { try { connection.rollback(); } catch (SailException e1) { e1.printStackTrace(); } } try { connection.commit(); } catch (SailException e) { e.printStackTrace(); } }
public void commit() throws SailException { if (uncommittedChanges) { cacheConnection.commit(); baseSailConnection.commit(); uncommittedChanges = false; } }
protected static Resource _processType( String typeID, NativeObject typeNO, String baseURL, SailConnection sailConnection) throws SailException { String label = _getStringProperty(typeNO, "label"); String pluralLabel = _getStringProperty(typeNO, "pluralLabel"); String uri = _getStringProperty(typeNO, "uri"); if (label == null) { label = typeID; } if (pluralLabel == null) { pluralLabel = label; } if (uri == null) { uri = baseURL + _encode(typeID); } Resource resource = new URIImpl(uri); sailConnection.addStatement(resource, RDF.TYPE, OWL.CLASS); sailConnection.addStatement(resource, ExhibitOntology.ID, new LiteralImpl(typeID)); sailConnection.addStatement(resource, RDFS.LABEL, new LiteralImpl(label)); sailConnection.addStatement( resource, ExhibitOntology.PLURAL_LABEL, new LiteralImpl(pluralLabel)); return resource; }
// Note: adding statements does not change the configuration of cached // values. public void addStatement( final Resource subj, final URI pred, final Value obj, final Resource... contexts) throws SailException { cacheConnection.addStatement(subj, pred, obj, contexts); baseSailConnection.addStatement(subj, pred, obj, contexts); uncommittedChanges = true; }
public CloseableIteration<? extends Statement, SailException> getStatements( final Resource subj, final URI pred, final Value obj, final boolean includeInferred, final Resource... context) throws SailException { if (null != subj && cacheSubject) { if (!cachedSubjects.contains(subj)) { cacheStatements(subj, null, null); cachedSubjects.add(subj); } return cacheConnection.getStatements(subj, pred, obj, includeInferred, context); } else if (null != obj && cacheObject) { if (!cachedObjects.contains(obj)) { cacheStatements(null, null, obj); cachedObjects.add(obj); } return cacheConnection.getStatements(subj, pred, obj, includeInferred, context); } else if (null != pred && cachePredicate) { if (!cachedPredicates.contains(pred)) { cacheStatements(null, pred, null); cachedPredicates.add(pred); } return cacheConnection.getStatements(subj, pred, obj, includeInferred, context); } else { return baseSailConnection.getStatements(subj, pred, obj, includeInferred, context); } }
@Override public void executeUpdate( final UpdateExpr updateExpr, final Dataset dataset, final BindingSet bindingSet, final boolean b) throws SailException { cacheConnection.executeUpdate(updateExpr, dataset, bindingSet, b); baseSailConnection.executeUpdate(updateExpr, dataset, bindingSet, b); uncommittedChanges = true; }
public CloseableIteration<? extends Namespace, SailException> getNamespaces() throws SailException { if (config.logReadOperations) { queryHandler.handle(new GetNamespacesCall(id)); return new RecorderIteration<Namespace, SailException>( (CloseableIteration<Namespace, SailException>) baseSailConnection.getNamespaces(), nextIterationId(), queryHandler); } else { return baseSailConnection.getNamespaces(); } }
@Override public void disconnect() { setConnected(false); try { if (connection.isOpen()) { connection.close(); } } catch (SailException e) { e.printStackTrace(); } }
protected void clearInternal(final Resource... contexts) throws SailException { if (0 == contexts.length) { baseSailConnection.clear(singleContext); } else { for (Resource context : contexts) { if (null != context && context.equals(singleContext)) { baseSailConnection.clear(singleContext); break; } } } }
protected long sizeInternal(final Resource... contexts) throws SailException { if (0 == contexts.length) { return baseSailConnection.size(singleContext); } else { for (Resource context : contexts) { if (null != context && context.equals(singleContext)) { return baseSailConnection.size(singleContext); } } return 0; } }
@Override public void connect() { if (!isConnected()) { setConnected(true); try { if (connection != null && connection.isOpen()) { connection.close(); } connection = sail.getConnection(); } catch (SailException e) { e.printStackTrace(); } } }
protected void addStatementInternal( final Resource subj, final URI pred, final Value obj, final Resource... contexts) throws SailException { if (0 == contexts.length) { baseSailConnection.addStatement(subj, pred, obj, singleContext); } else { for (Resource context : contexts) { if (null != context && context.equals(singleContext)) { baseSailConnection.addStatement(subj, pred, obj, singleContext); break; } } } }
protected static void _addItemProperty( Resource itemResource, URI predicate, Object valueO, String baseURL, SailConnection dataConnection, SailConnection metaConnection, Map<String, String> itemIDToURI) throws SailException { if (valueO == null) return; String valueType = _getObjectString(predicate, ExhibitOntology.VALUE_TYPE, metaConnection); Value object = null; if ("item".equals(valueType)) { String id = valueO.toString(); String uri = itemIDToURI.get(id); try { object = new URIImpl(uri); } catch (Exception e) { object = new URIImpl(baseURL + _encode(id)); } } else if (valueO instanceof Double) { double d = ((Double) valueO).doubleValue(); if (d != Math.floor(d)) { object = new LiteralImpl(valueO.toString() /*, XMLSchema.DOUBLE*/); } else { object = new LiteralImpl(Long.toString(((Double) valueO).longValue()) /*, XMLSchema.LONG*/); } } else { object = new LiteralImpl(valueO.toString()); } dataConnection.addStatement(itemResource, predicate, object); }
protected static URI _ensurePropertyExists( String propertyID, String baseURL, SailConnection sailConnection) throws SailException { URI predicate = (URI) _getSubject(ExhibitOntology.ID, new LiteralImpl(propertyID), sailConnection); if (predicate == null) { String label = propertyID; String uri = baseURL + _encode(propertyID); predicate = new URIImpl(uri); sailConnection.addStatement(predicate, RDF.TYPE, OWL.CLASS); sailConnection.addStatement(predicate, ExhibitOntology.ID, new LiteralImpl(propertyID)); sailConnection.addStatement(predicate, RDFS.LABEL, new LiteralImpl(label)); sailConnection.commit(); } return predicate; }
private void cacheStatements(final Resource subj, final URI pred, final Value obj) throws SailException { boolean includeInferred = false; CloseableIteration<? extends Statement, SailException> iter = baseSailConnection.getStatements(subj, pred, obj, includeInferred); while (iter.hasNext()) { Statement st = iter.next(); cacheConnection.addStatement( st.getSubject(), st.getPredicate(), st.getObject(), st.getContext()); } iter.close(); cacheConnection.commit(); }
// Note: adding statements does not change the configuration of cached // values. public void addStatement( final Resource subj, final URI pred, final Value obj, final Resource... contexts) throws SailException { if (config.logWriteOperations) { queryHandler.handle(new AddStatementCall(id, subj, pred, obj, contexts)); } baseSailConnection.addStatement(subj, pred, obj, contexts); }
protected static Resource _ensureTypeExists( String typeID, String baseURL, SailConnection sailConnection) throws SailException { Resource resource = _getSubject(ExhibitOntology.ID, new LiteralImpl(typeID), sailConnection); if (resource == null) { String label = typeID; String pluralLabel = label; String uri = baseURL + _encode(typeID); resource = new URIImpl(uri); sailConnection.addStatement(resource, RDF.TYPE, OWL.CLASS); sailConnection.addStatement(resource, ExhibitOntology.ID, new LiteralImpl(typeID)); sailConnection.addStatement(resource, RDFS.LABEL, new LiteralImpl(label)); sailConnection.addStatement( resource, ExhibitOntology.PLURAL_LABEL, new LiteralImpl(pluralLabel)); sailConnection.commit(); } return resource; }
public CloseableIteration<? extends Statement, SailException> getStatements( final Resource subj, final URI pred, final Value obj, final boolean includeInferred, final Resource... contexts) throws SailException { if (config.logReadOperations) { queryHandler.handle(new GetStatementsCall(id, subj, pred, obj, includeInferred, contexts)); return new RecorderIteration<Statement, SailException>( (CloseableIteration<Statement, SailException>) baseSailConnection.getStatements(subj, pred, obj, includeInferred, contexts), nextIterationId(), queryHandler); } else { return baseSailConnection.getStatements(subj, pred, obj, includeInferred, contexts); } }
public CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluate( final TupleExpr tupleExpr, final Dataset dataSet, final BindingSet bindingSet, final boolean includeInferred) throws SailException { // Note: there is no EvaluateCall, nor is there a recording iterator for evaluate() results return baseSailConnection.evaluate(tupleExpr, dataSet, bindingSet, includeInferred); }
@Override public void delete(String graphURI) { try { if (graphURI == null) { connection.clear(); connection.commit(); } else { connection.clear(new ValueFactoryImpl().createURI(graphURI)); connection.commit(); } } catch (SailException e) { e.printStackTrace(); try { connection.rollback(); } catch (SailException e1) { e1.printStackTrace(); } } }
protected CloseableIteration<? extends Statement, SailException> getStatementsInternal( final Resource subj, final URI pred, final Value obj, final boolean includeInferred, final Resource... contexts) throws SailException { if (0 == contexts.length) { return baseSailConnection.getStatements(subj, pred, obj, includeInferred, singleContext); } else { for (Resource context : contexts) { if (null != context && context.equals(singleContext)) { return baseSailConnection.getStatements(subj, pred, obj, includeInferred, singleContext); } } return new EmptyCloseableIteration<Statement, SailException>(); } }
protected static Value _getObject(Resource subject, URI predicate, SailConnection c) throws SailException { CloseableIteration<? extends Statement, SailException> i = c.getStatements(subject, predicate, null, true); try { if (i.hasNext()) { return i.next().getObject(); } else { return null; } } finally { i.close(); } }
protected boolean containsGraph(String graph) { connect(); try { for (CloseableIteration<? extends Resource, SailException> res = connection.getContextIDs(); res.hasNext(); ) { Resource r = res.next(); if (r.stringValue().equals(graph.toString())) return true; } } catch (SailException e) { e.printStackTrace(); } disconnect(); return false; }
protected CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluateInternal( final TupleExpr tupleExpr, final Dataset dataSet, final BindingSet bindingSet, final boolean includeInferred) throws SailException { // ignore the given dataset and restrict everything to the single context we have been setup // with DatasetImpl singleContextDataset = new DatasetImpl(); if (singleContext instanceof URI) { singleContextDataset.setDefaultInsertGraph((URI) singleContext); singleContextDataset.addDefaultGraph((URI) singleContext); singleContextDataset.addNamedGraph((URI) singleContext); singleContextDataset.addDefaultRemoveGraph((URI) singleContext); } return baseSailConnection.evaluate( tupleExpr, singleContextDataset, bindingSet, includeInferred); }
public void handleStatement(Statement arg0) { try { // avoid self-cycles if (arg0.getSubject().stringValue().equals(arg0.getObject().stringValue())) return; sc.addStatement(arg0.getSubject(), arg0.getPredicate(), arg0.getObject()); manager.incrCounter(); if (manager.atCommit()) System.out.print("."); } catch (SailException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); System.out.println( "Subject: " + arg0.getSubject().toString() + " Predicate: " + arg0.getPredicate().toString() + " Object: " + arg0.getObject().toString()); } }
@Override public IResultSet<Value, URI, Literal> selectQuery(String query, String graph) { connect(); final SPARQLParser parser = new SPARQLParser(); CloseableIteration<? extends BindingSet, QueryEvaluationException> sparqlResults = null; ParsedQuery parsedQuery = null; try { parsedQuery = parser.parseQuery(query, null); } catch (MalformedQueryException e) { e.printStackTrace(); } try { sparqlResults = connection.evaluate( parsedQuery.getTupleExpr(), parsedQuery.getDataset(), new EmptyBindingSet(), false); } catch (SailException e) { e.printStackTrace(); } return new SailResultSet(sparqlResults); }
public void commit() throws SailException { if (config.logTransactions) { queryHandler.handle(new CommitCall(id)); } baseSailConnection.commit(); }
public void clearNamespaces() throws SailException { if (config.logWriteOperations) { queryHandler.handle(new ClearNamespacesCall(id)); } baseSailConnection.clearNamespaces(); }
// Note: clearing statements does not change the configuration of cached // values. public void clear(final Resource... contexts) throws SailException { if (config.logWriteOperations) { queryHandler.handle(new ClearCall(id, contexts)); } baseSailConnection.clear(contexts); }