public static QueryExecution create(String queryStr, Model model) { checkArg(queryStr); checkArg(model); if (model.getGraph() instanceof VirtGraph) { VirtuosoQueryExecution ret = new VirtuosoQueryExecution(queryStr, (VirtGraph) model.getGraph()); return ret; } else { return create(makeQuery(queryStr), model); } }
/** * test that two models are isomorphic and fail if they are not. * * @param title a String appearing at the beginning of the failure message * @param wanted the model value that is expected * @param got the model value to check * @exception if the models are not isomorphic */ public static void assertIsoModels(String title, Model wanted, Model got) { if (wanted.isIsomorphicWith(got) == false) { Map<Node, Object> map = CollectionFactory.createHashedMap(); fail( title + ": expected " + nice(wanted.getGraph(), map) + "\n but had " + nice(got.getGraph(), map)); } }
public static QueryExecution create(Query query, Model model) { checkArg(query); checkArg(model); if (model.getGraph() instanceof VirtGraph) { VirtuosoQueryExecution ret = new VirtuosoQueryExecution(query.toString(), (VirtGraph) model.getGraph()); return ret; } else { return make(query, new DatasetImpl(model)); } }
public static String RenderTemplatePage(Bindings b, String templateName) throws IOException { MediaType mt = MediaType.TEXT_HTML; Resource config = model.createResource("eh:/root"); Mode prefixMode = Mode.PreferPrefixes; ShortnameService sns = new StandardShortnameService(); List<Resource> noResults = CollectionUtils.list(root.inModel(model)); Graph resultGraph = graphModel.getGraph(); resultGraph.getPrefixMapping().setNsPrefix("api", API.NS); resultGraph.add(Triple.create(root.asNode(), API.items.asNode(), RDF.nil.asNode())); APIResultSet rs = new APIResultSet(resultGraph, noResults, true, true, "details", View.ALL); VelocityRenderer vr = new VelocityRenderer(mt, null, config, prefixMode, sns); VelocityRendering vx = new VelocityRendering(b, rs, vr); VelocityEngine ve = vx.createVelocityEngine(); VelocityContext vc = vx.createVelocityContext(b); ByteArrayOutputStream bos = new ByteArrayOutputStream(); Writer w = new OutputStreamWriter(bos, "UTF-8"); Template t = ve.getTemplate(templateName); t.merge(vc, w); w.close(); return bos.toString(); }
/** * Query SPARQL endpoint with a SELECT query * * @param qExec QueryExecution encapsulating the query * @return model retrieved by querying the endpoint */ private Model getSelectModel(QueryExecution qExec) { Model model = ModelFactory.createDefaultModel(); Graph graph = model.getGraph(); ResultSet results = qExec.execSelect(); while (results.hasNext()) { QuerySolution sol = results.next(); String subject; String predicate; RDFNode object; try { subject = sol.getResource("s").toString(); predicate = sol.getResource("p").toString(); object = sol.get("o"); } catch (NoSuchElementException e) { logger.error("SELECT query does not return a (?s ?p ?o) Triple"); continue; } Node objNode; if (object.isLiteral()) { Literal obj = object.asLiteral(); objNode = NodeFactory.createLiteral(obj.getString(), obj.getDatatype()); } else { objNode = NodeFactory.createLiteral(object.toString()); } graph.add( new Triple(NodeFactory.createURI(subject), NodeFactory.createURI(predicate), objNode)); } return model; }
/** * Returns a collection of RDFStatements that match the described subject * * @param subject Subject * @return collection of RDFStatements */ public Collection<RDFStatement> getStatements(String subject) { if (subject == null || subject.isEmpty()) { return null; } List<RDFStatement> statement = null; try { // define a describe query String query = String.format("DESCRIBE %s FROM < %s >", subject, this.graphName); logger.debug("Query: \n{}", query); Query sparqlQuery = QueryFactory.create(query); VirtuosoQueryExecution vqe = VirtuosoQueryExecutionFactory.create(sparqlQuery, this.graph); // execute the query and get the graph Model model = vqe.execDescribe(); Graph queriedGraph = model.getGraph(); // itreate over the retrieved triples, and place them inside a list ExtendedIterator<Triple> iter = queriedGraph.find(Node.ANY, Node.ANY, Node.ANY); statement = new ArrayList<>(); while (iter.hasNext()) { Triple t = (Triple) iter.next(); RDFStatement stmt = new RDFStatement( t.getSubject().toString(), t.getPredicate().toString(), t.getObject().toString()); statement.add(stmt); } } catch (Exception ex) { logger.error("Exception occured while querying for statements", ex); } return statement; }
public SPDXChecksum(Model spdxModel, Node checksumNode) throws InvalidSPDXAnalysisException { this.model = spdxModel; this.checksumNode = checksumNode; if (checksumNode.isBlank()) { checksumResource = model.createResource(checksumNode.getBlankNodeId()); } else if (checksumNode.isURI()) { checksumResource = model.createResource(checksumNode.getURI()); } else { throw (new InvalidSPDXAnalysisException("Checksum node can not be a literal")); } // Algorithm Node p = spdxModel .getProperty(SpdxRdfConstants.SPDX_NAMESPACE, SpdxRdfConstants.PROP_CHECKSUM_ALGORITHM) .asNode(); Triple m = Triple.createMatch(checksumNode, p, null); ExtendedIterator<Triple> tripleIter = spdxModel.getGraph().find(m); while (tripleIter.hasNext()) { Triple t = tripleIter.next(); if (t.getObject().isLiteral()) { // The following is for compatibility with rdf generated with older // versions of the tool this.algorithm = t.getObject().toString(false); } else if (t.getObject().isURI()) { this.algorithm = URI_TO_ALGORITHM.get(t.getObject().getURI()); if (this.algorithm == null) { this.algorithm = "UNKNOWN"; } } else { throw (new InvalidSPDXAnalysisException( "Invalid checksum algorithm - must be one of the defined algorithms supported by SPDX.")); } } // value p = spdxModel .getProperty(SpdxRdfConstants.SPDX_NAMESPACE, SpdxRdfConstants.PROP_CHECKSUM_VALUE) .asNode(); m = Triple.createMatch(checksumNode, p, null); tripleIter = spdxModel.getGraph().find(m); while (tripleIter.hasNext()) { Triple t = tripleIter.next(); this.value = t.getObject().toString(false); } }
/** * @param mGraph * @return */ protected static Graph getHiddenTriples(Model m) { Graph mGraph = m.getGraph(); final Reifier r = mGraph.getReifier(); return new GraphBase() { public ExtendedIterator graphBaseFind(TripleMatch m) { return r.findEither(m, true); } }; }
@Override public Graph getGraph(Node graphNode) { Model model = dataset.getNamedModel(graphNode.getURI()); if (model != null) { return getControlledUpdateGraph(model.getGraph()); } else { return null; } }
@Override public Graph getDefaultGraph() { Model defaultModel = dataset.getDefaultModel(); if (defaultModel != null) { return getControlledUpdateGraph(defaultModel.getGraph()); } else { return null; } }
/** * Attempts to load a graph with a given URI. In the default implementation, this uses the Jena * OntDocumentManager and default loading mechanisms. Subclasses can override this. * * @param uri the base URI of the graph to load * @return the Graph or null to ignore this * @throws IOException */ protected Graph getImportedGraph(String uri) throws IOException { Model model = OntDocumentManager.getInstance().getModel(uri); if (model == null) { Model baseModel = JenaUtil.createDefaultModel(); baseModel.read(uri); model = JenaUtil.createOntologyModel(OntModelSpec.OWL_MEM, baseModel); OntDocumentManager.getInstance().addModel(uri, model); } return model.getGraph(); }
private Node walkTree( Model model, Dataset oldDataset, Node node, Node predicate, Query query, QuerySolution initialBinding, Set<Node> reached) { QuerySolutionMap localBinding = new QuerySolutionMap(); localBinding.addAll(initialBinding); localBinding.add("arg1", model.asRDFNode(node)); Dataset dataset = new DatasetWithDifferentDefaultModel(model, oldDataset); QueryExecution qexec = ARQFactory.get().createQueryExecution(query, dataset, localBinding); ResultSet rs = qexec.execSelect(); try { if (rs.hasNext()) { List<String> resultVars = rs.getResultVars(); String varName = resultVars.get(0); RDFNode resultNode = rs.next().get(varName); if (resultNode != null) { return resultNode.asNode(); } } } finally { qexec.close(); } // Recurse into parents ExtendedIterator<Triple> it = createIterator(model.getGraph(), node, predicate); try { while (it.hasNext()) { Node next = getNext(it.next()); if ((next.isBlank() || next.isURI()) && !reached.contains(next)) { reached.add(next); Node nextResult = walkTree(model, oldDataset, next, predicate, query, initialBinding, reached); if (nextResult != null) { return nextResult; } } } } finally { it.close(); } return null; }
/** * Checks if spin:imports have been declared and adds them to a union model. Will also register * any SPIN modules defined in those imports that haven't been loaded before. * * @param model the base Model to operate on * @return either model or the union of model and its spin:imports @ */ public Model getImportsModel(Model model) throws IOException { Set<String> uris = new HashSet<String>(); StmtIterator it = model.listStatements(null, SPIN.imports, (RDFNode) null); while (it.hasNext()) { Statement s = it.nextStatement(); if (s.getObject().isURIResource()) { uris.add(s.getResource().getURI()); } } if (uris.isEmpty()) { return model; } else { Graph baseGraph = model.getGraph(); MultiUnion union = JenaUtil.createMultiUnion(); union.addGraph(baseGraph); union.setBaseGraph(baseGraph); boolean needsRegistration = false; for (String uri : uris) { Graph graph = getImportedGraph(uri); if (graph != null) { union.addGraph(graph); if (!registeredURIs.contains(uri)) { registeredURIs.add(uri); needsRegistration = true; } } } // Ensure that SP, SPIN and SPL are present ensureImported(union, SP.BASE_URI, SP.getModel()); ensureImported(union, SPL.BASE_URI, SPL.getModel()); ensureImported(union, SPIN.BASE_URI, SPIN.getModel()); Model unionModel = ModelFactory.createModelForGraph(union); if (needsRegistration) { SPINModuleRegistry.get().registerAll(unionModel, null); } return unionModel; } }
/** * Answer a version of the model, but with all its reifiying statements added. * * @param m a model that may have reified statements * @return a new model, the union of m and the reification statements of m */ public static Model withHiddenStatements(Model m) { Graph mGraph = m.getGraph(); Graph hiddenTriples = getHiddenTriples(m); return new ModelCom(new DisjointUnion(mGraph, hiddenTriples)); }
private void ensureImported(MultiUnion union, String baseURI, Model model) { if (!union.contains( Triple.create(NodeFactory.createURI(baseURI), RDF.type.asNode(), OWL.Ontology.asNode()))) { union.addGraph(model.getGraph()); } }
public static void loadModel(Model model, String uri, int limit) { Graph g = model.getGraph(); readUtil(g, uri, limit); }