public static Dataset exportToDAQ(String datasetPLD) { datasetPLD = datasetPLD.replace("http://", ""); datasetPLD = datasetPLD.replace("https://", ""); datasetPLD = datasetPLD.replace("uri:", ""); datasetPLD = datasetPLD.replace(":", "_"); String graph = datasets_metadata.get(datasetPLD); Model m = d.getNamedModel(graph); Model defModel = ModelFactory.createDefaultModel(); defModel.add(d.getDefaultModel().listStatements(m.createResource(graph), (Property) null, (RDFNode) null).toList()); Dataset daq = DatasetFactory.create(); daq.addNamedModel(graph, m); daq.getDefaultModel().add(defModel); return daq; }
public static void write(PrintStream out, DatasetGraph dg) { Dataset ds = DatasetFactory.wrap(dg); Model dm = ds.getDefaultModel(); if(!dm.isEmpty()) { out.println("Begin of Default model -----------------------"); dm.write(out, "TURTLE"); out.println("End of Default model -----------------------"); } Iterator<String> it = ds.listNames(); while(it.hasNext()) { String name = it.next(); Model model = ds.getNamedModel(name); System.out.println("Begin of " + name + " -----------------------"); model.write(out, "TURTLE"); System.out.println("End of " + name + " -----------------------"); } }
@Override public Dataset createDataset() { // If nothing specified for this module, Leave alone and hope the query has FROM/FROM NAMED if ( (dataURLs == null || dataURLs.size() == 0) && (graphURLs == null || graphURLs.size() == 0) && (namedGraphURLs == null || namedGraphURLs.size() == 0) ) return null ; Dataset ds = DatasetFactory.createTxnMem() ; addGraphs(ds) ; dataset = ds ; return dataset ; }
@Test public void generalDataset3() { Dataset ds = create() ; load1(ds.getDefaultModel()) ; load2(ds.getNamedModel("http://example/graph1")) ; load3(ds.getNamedModel("http://example/graph2")) ; Model m = ds.getDefaultModel() ; // Use the default model in one dataset as a named model in another. Dataset ds2 = DatasetFactory.createGeneral() ; ds2.addNamedModel("http://example/graphOther", m) ; String qs = "CONSTRUCT {?s ?p ?o } WHERE { {?s ?p ?o} UNION { GRAPH <http://example/graphOther> {?s ?p ?o} } }" ; Query q = QueryFactory.create(qs) ; QueryExecution qExec = QueryExecutionFactory.create(q, ds2) ; Model m2 = qExec.execConstruct() ; assertTrue(m.isIsomorphicWith(m2)) ; }
private void removeBlankNodesWithSparqlUpdate(Dataset dataset, Model model, String graphURI) { StmtIterator stmtIt = model.listStatements(); while (stmtIt.hasNext()) { Statement stmt = stmtIt.nextStatement(); blankNodeModel.add(blankNodeStatements); log.debug("removal model size " + model.size()); Resource s = qs.getResource("s"); String treeFinder = makeDescribe(s); Query treeFinderQuery = QueryFactory.create(treeFinder); QueryExecution qee = QueryExecutionFactory.create(treeFinderQuery, blankNodeModel); try { Model tree = qee.execDescribe(); Dataset ds = DatasetFactory.createMem(); if (graphURI == null) { ds.setDefaultModel(dataset.getDefaultModel()); } else { ds.addNamedModel(graphURI, dataset.getNamedModel(graphURI)); Query smallerTreeQuery = QueryFactory.create(smallerTree); QueryExecution qe3 = QueryExecutionFactory.create( smallerTreeQuery, tree); try { qe3.execDescribe(m2);
private void removeUsingSparqlUpdate(Dataset dataset, Model model, String graphURI) { StmtIterator stmtIt = model.listStatements(); queryBuff.append(" GRAPH <").append(graphURI).append("> { \n"); stmtIt = model.listStatements(); stmts = stmtIt.toList(); stmts = sort(stmts); Query construct = QueryFactory.create(queryBuff.toString()); Dataset ds = DatasetFactory.createMem(); if (graphURI == null) { ds.setDefaultModel(dataset.getDefaultModel()); } else { ds.addNamedModel(graphURI, dataset.getNamedModel(graphURI)); QueryExecution qe = QueryExecutionFactory.create(construct, ds); try { Model m = qe.execConstruct(); if (graphURI != null) { dataset.getNamedModel(graphURI).remove(m); } else { dataset.getDefaultModel().remove(m); qe.close();
public static int count(String queryStr, DatasetGraph dsg) { int counter = 0 ; Query query = QueryFactory.create(queryStr, Syntax.syntaxARQ) ; try (QueryExecution qExec = QueryExecutionFactory.create(query, DatasetFactory.wrap(dsg))) { ResultSet rs = qExec.execSelect() ; for ( ; rs.hasNext() ; ) { rs.nextBinding() ; counter++ ; } return counter ; } }
@Test public void generalDataset1() { Dataset ds = dataset() ; load1(ds.getDefaultModel()) ; load2(ds.getNamedModel("http://example/graph1")) ; load3(ds.getNamedModel("http://example/graph2")) ; Model m = ds.getNamedModel("http://example/graph2") ; // Use graph2 as default model. Dataset ds2 = DatasetFactory.create() ; ds2.setDefaultModel(ds.getNamedModel("http://example/graph2")) ; String qs = "CONSTRUCT {?s ?p ?o } WHERE { ?s ?p ?o}" ; Query q = QueryFactory.create(qs) ; QueryExecution qExec = QueryExecutionFactory.create(q, ds2) ; Model m2 = qExec.execConstruct() ; assertTrue(m.isIsomorphicWith(m2)) ; }
@Test public void generalDataset1() { Dataset ds = create() ; load1(ds.getDefaultModel()) ; load2(ds.getNamedModel("http://example/graph1")) ; load3(ds.getNamedModel("http://example/graph2")) ; Model m = ds.getNamedModel("http://example/graph2") ; // Use graph2 as default model. Dataset ds2 = DatasetFactory.createGeneral() ; ds2.setDefaultModel(ds.getNamedModel("http://example/graph2")) ; String qs = "CONSTRUCT {?s ?p ?o } WHERE { ?s ?p ?o}" ; Query q = QueryFactory.create(qs) ; QueryExecution qExec = QueryExecutionFactory.create(q, ds2) ; Model m2 = qExec.execConstruct() ; assertTrue(m.isIsomorphicWith(m2)) ; }
private void testEmptyGroupBy(String qsAgg, DatasetGraph ds, Syntax syntax) { Query query = buildGroupBy(qsAgg, syntax) ; try ( QueryExecution qExec = QueryExecutionFactory.create(query, DatasetFactory.wrap(ds)) ) { ResultSet rs = qExec.execSelect() ; assertFalse(rs.hasNext()) ; } } }
/** * @param serviceURI String * @param servicePredicate String * @param serviceType String */ ServiceNodeWriter(final String serviceURI, final String servicePredicate, final String serviceType) { final Model model = ModelFactory.createDefaultModel(); final Resource s = model.createResource(getIdentitySubject()); final Property p = model.createProperty(servicePredicate); final Resource o = model.createResource(serviceURI); model.add(s, p, o); final Dataset dataset = DatasetFactory.create(model); dataset.addNamedModel("http://iiif.service", model); this.serviceNode = new ByteArrayOutputStream(); RDFDataMgr.write(this.serviceNode, model, Lang.NTRIPLES); }
@Test public void testVariableSPO4() { // Don't handle variable SPO pattern in the query. The result set size // is incomplete. final String q = "SELECT * WHERE { ?s ?p ?o }"; final Resource s = ResourceFactory.createResource(NS + "i"); final Property p = ResourceFactory.createProperty(NS + "p"); final Resource o = ResourceFactory.createResource(NS + "C"); final Model model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); model.add(s, p, o); final Query query = QueryFactory.create(q); final QueryExecution qe = SparqlDLExecutionFactory.create(query, DatasetFactory.create(model), null, QueryEngineType.PELLET, false); final ResultSet rs = qe.execSelect(); ResultSetFormatter.consume(rs); assertEquals(1, rs.getRowNumber()); }
@Test public void testInitialBindings7() { // JENA-1354 Query query = QueryFactory.create("SELECT DISTINCT ?x WHERE {}"); Dataset ds = DatasetFactory.create(); QuerySolutionMap initialBinding = new QuerySolutionMap(); initialBinding.add("a", ResourceFactory.createTypedLiteral(Boolean.TRUE)); try ( QueryExecution qexec = QueryExecutionFactory.create(query, ds, initialBinding) ) { assertFalse(qexec.execSelect().next().contains("a")); } }
public static void executeQuery(HttpServletResponse response, Query query, Model model) throws IOException { Dataset dataset = DatasetFactory.create(model); QueryExecution qe = QueryExecutionFactory.create(query, dataset); try { ResultSet results = qe.execSelect(); response.setContentType(RESPONSE_MIME_TYPE); OutputStream out = response.getOutputStream(); ResultSetFormatter.outputAsJSON(out, results); } finally { qe.close(); } }
public Dataset retrieveNeedDataset(String uri) { String queryString = "prefix won: <http://purl.org/webofneeds/model#> select distinct ?g where { " + "GRAPH ?g { ?uri a won:Need. ?a ?b ?c. } }"; ParameterizedSparqlString pps = new ParameterizedSparqlString(); pps.setCommandText(queryString); pps.setIri("uri", uri); Query query = QueryFactory.create(pps.toString()); QueryExecution qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); ResultSet results = qexec.execSelect(); Dataset ds = DatasetFactory.createGeneral(); while (results.hasNext()) { QuerySolution qs = results.next(); String graphUri = qs.getResource("g").getURI(); Model model = retrieveModel(graphUri); ds.addNamedModel(graphUri, model); } return ds; }
@Test public void testARQConstructQuad_ShortForm_2() { String queryString = "CONSTRUCT WHERE { GRAPH ?g {?s ?p ?o} }"; Query q = QueryFactory.create(queryString, Syntax.syntaxARQ); QueryExecution qExec = QueryExecutionFactory.create(q, d); Dataset result = qExec.execConstructDataset(); Dataset expected = DatasetFactory.createTxnMem(); expected.addNamedModel(g1.getURI(), m); assertTrue(IsoMatcher.isomorphic( expected.asDatasetGraph(), result.asDatasetGraph()) ); }
private void isolationModel(Isolation level, boolean expected) { Dataset base = DatasetFactory.createTxnMem(); Statement stmt = base.getDefaultModel().createStatement(subject, property, object); RDFConnection conn1 = RDFConnectionFactory.connect(base, level); try (RDFConnection conn2 = conn1;) { Model m = conn2.fetch(); m.add(stmt); } assertEquals(expected, base.getDefaultModel().contains(stmt)); } }
private void test(String queryString, String jsonExpected) { Query query = QueryFactory.create(queryString, Syntax.syntaxARQ); DatasetGraph dsg = new DatasetGraphZero(); Dataset ds = DatasetFactory.wrap(dsg); try ( QueryExecution qExec = QueryExecutionFactory.create(query, ds) ) { JsonValue jvGot = qExec.execJson() ; JsonValue jvExpected = JSON.parseAny(jsonExpected) ; assertEquals(jvExpected, jvGot); } } }
/** * Create a new need model (incluing sysinfo) * * @param needUri need uri to create the need models for */ public NeedModelWrapper(String needUri) { needDataset = DatasetFactory.create(); Model needModel = ModelFactory.createDefaultModel(); DefaultPrefixUtils.setDefaultPrefixes(needModel); needModel.createResource(needUri, WON.NEED); Model sysInfoModel = ModelFactory.createDefaultModel(); DefaultPrefixUtils.setDefaultPrefixes(sysInfoModel); sysInfoModel.createResource(needUri, WON.NEED); this.needModelGraphName = "dummy#need"; needDataset.addNamedModel(this.needModelGraphName, needModel); this.sysInfoGraphName = "dummy#sysinfo"; needDataset.addNamedModel(this.sysInfoGraphName, sysInfoModel); }
@Test public void testDAWG3() { // Query PREFIX : <http://example/> SELECT * { ?s ?p ?o } // The same as testDAWG2 but this time we don't handle the variable SPO // pattern, i.e. we handle the pattern as a property value final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); model.read("file:test/data/sparql-dawg-tests/data-r2/graph/data-g1.ttl", "N3"); final Query query = QueryFactory.read("file:test/data/sparql-dawg-tests/data-r2/graph/graph-01.rq"); final QueryExecution qe = SparqlDLExecutionFactory.create(query, DatasetFactory.create(model), null, QueryEngineType.MIXED, false); final ResultSet rs = qe.execSelect(); ResultSetFormatter.consume(rs); assertEquals(2, rs.getRowNumber()); }