@Override public Iterator<Triple> get() { Iterator<Triple> r = decoratee.execConstructTriples(); return r; } });
@Override public Iterator<Triple> execConstructTriples() { for (QueryExecution qe : decoratees) { try { return qe.execConstructTriples(); } catch (Exception e) { logger.warn(String.format("Query execution failed. Tried %s", qe), e); } } throw new QueryExecutionFallbackFailedException(); }
public static Iterator<Triple> createIteratorDumpTriples(QueryExecutionFactory qef) { //Query query = CannedQueryUtils.spoTemplate(); String queryStr = "Construct { ?s ?p ?o } { ?s ?p ?o }"; QueryExecution qe = qef.createQueryExecution(queryStr); Iterator<Triple> result = qe.execConstructTriples(); return result; }
public Iterator<Triple> describeNodeStreaming(Node node) { Query query = CannedQueryUtils.constructBySubject(node); QueryExecution qe = qef.createQueryExecution(query); return qe.execConstructTriples(); }
} else { QueryExecution qe = qef.createQueryExecution(query); Iterator<Triple> triplesIt = qe.execConstructTriples();
public static void processExecConstructTriples(FlowableEmitter<Triple> emitter, QueryExecution qe) { try { emitter.setCancellable(qe::abort); Iterator<Triple> it = qe.execConstructTriples(); while(!emitter.isCancelled() && it.hasNext()) { Triple item = it.next(); emitter.onNext(item); } emitter.onComplete(); } catch (Exception e) { emitter.onError(e); } }
@Override public Iterator<Triple> execConstructTriples() { beforeExec(); try { return decoratee.execConstructTriples(); } catch(Exception e) { onException(e); // throw new RuntimeException(e); throw e; } finally { afterExec(); } }
/** * Copy data from one sparql service to another based on a construct query * * @param target * @param source * @param constructQueryStr * @param batchSize */ public static void copyByConstruct(SparqlService target, SparqlService source, String constructQueryStr, int batchSize) { Query query = QueryFactory.create(constructQueryStr, "http://example.org/", Syntax.syntaxARQ); QueryExecution qe = source.getQueryExecutionFactory().createQueryExecution(query); Iterator<Triple> it = qe.execConstructTriples(); Iterator<List<Triple>> itPart = Iterators.partition(it, batchSize); while(itPart.hasNext()) { List<Triple> part = itPart.next(); logger.debug("Items in this chunk: " + part.size()); executeInsertTriples(target.getUpdateExecutionFactory(), part); } logger.debug("Done with this chunk"); }
Iterator<Triple> result = currentQe.execConstructTriples(); return result;
/** * Exec construct with wrapper to extended iterator * @param qef * @param query * @return */ public static ExtendedIterator<Triple> execConstruct(QueryExecutionFactory qef, Query query) { QueryExecution qe = qef.createQueryExecution(query); Iterator<Triple> it = qe.execConstructTriples(); ExtendedIteratorClosable<Triple> result = ExtendedIteratorClosable.create(it, () -> { tryClose(it); qe.close();}); //WrappedIterator<Triple> result = WrappedIterator.<Triple>createNoRemove(it); return result; }
/** * CONSTRUCT queries are mapped to result sets with the variables ?s ?p ?o * */ public static ResultSet forceExecResultSet(QueryExecution qe, Query query) { ResultSet result; if(query.isSelectType()) { result = qe.execSelect(); } else if(query.isConstructType()) { Iterator<Triple> it = qe.execConstructTriples(); result = org.aksw.jena_sparql_api.core.utils.ResultSetUtils.tripleIteratorToResultSet(it, new CloseableQueryExecution(qe)); } else { throw new RuntimeException("Query type is not supported: " + query); } return result; }
public static void abortAfterFirstRow(QueryExecution qe) { Query query = qe.getQuery(); assert query != null : "QueryExecution did not tell us which query it is bound to - query was null"; int queryType = query.getQueryType(); try { switch (queryType) { case Query.QueryTypeAsk: qe.execAsk(); break; case Query.QueryTypeConstruct: Iterator<Triple> itC = qe.execConstructTriples(); itC.hasNext(); break; case Query.QueryTypeDescribe: Iterator<Triple> itD = qe.execDescribeTriples(); itD.hasNext(); break; case Query.QueryTypeSelect: ResultSet rs = qe.execSelect(); rs.hasNext(); break; default: throw new RuntimeException("Unknown query type - should not happen: queryType = " + queryType); } } finally { qe.abort(); } }
@Test public void testConstructRejectsBadTriples2() { String queryString = "CONSTRUCT { ?s ?p ?o } WHERE { ?o ?p ?s }"; Query q = QueryFactory.create(queryString); QueryExecution qExec = QueryExecutionFactory.create(q, m); Iterator<Triple> ts = qExec.execConstructTriples(); long count = 0; while (ts.hasNext()) { count++; ts.next(); } assertEquals(0, count); }
public Iterator<Triple> execTriples() throws IOException { Model model = ModelFactory.createDefaultModel(); ExtendedIterator<Triple> result = new NullIterator<Triple>(); for (Query q: tq.getQueries()) { modifyQuery(q, table); QueryExecution ex = createQueryExecution(q, model); result = result.andThen(ex.execConstructTriples()); } return result; }
@Override public void execute(RuleEngine ruleEngine, List<RDFNode> focusNodes, Shape shape) { ProgressMonitor monitor = ruleEngine.getProgressMonitor(); for(RDFNode focusNode : focusNodes) { if(monitor != null && monitor.isCanceled()) { return; } QuerySolutionMap bindings = new QuerySolutionMap(); bindings.add(SH.thisVar.getVarName(), focusNode); try(QueryExecution qexec = ARQFactory.get().createQueryExecution(query, ruleEngine.getDataset(), bindings)) { Iterator<Triple> it = qexec.execConstructTriples(); while(it.hasNext()) { Triple triple = it.next(); ruleEngine.infer(triple, this, shape); } } } }
@Override public void execute(RuleEngine ruleEngine, List<RDFNode> focusNodes, Shape shape) { ProgressMonitor monitor = ruleEngine.getProgressMonitor(); for(RDFNode focusNode : focusNodes) { if(monitor != null && monitor.isCanceled()) { return; } QuerySolutionMap bindings = new QuerySolutionMap(); bindings.add(SH.thisVar.getVarName(), focusNode); try(QueryExecution qexec = ARQFactory.get().createQueryExecution(query, ruleEngine.getDataset(), bindings)) { Iterator<Triple> it = qexec.execConstructTriples(); while(it.hasNext()) { Triple triple = it.next(); ruleEngine.infer(triple, this, shape); } } } }
break; case Query.QueryTypeConstruct: Iterator<Triple> itC = qe.execConstructTriples(); result = Iterators.size(itC); break;
@Test public void testARQConstructQuad_a_1() { String queryString = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH ?g { ?s ?p ?o } }"; Query q = QueryFactory.create(queryString, Syntax.syntaxARQ); QueryExecution qExec = QueryExecutionFactory.create(q, d); Iterator<Triple> ts = qExec.execConstructTriples(); Model result = ModelFactory.createDefaultModel(); while (ts.hasNext()) { Triple t = ts.next(); Statement stmt = ModelUtils.tripleToStatement(result, t); if ( stmt != null ) result.add(stmt); } assertEquals(3, result.size()); assertTrue(m.isIsomorphicWith(result)); }
@Test public void testARQConstructQuad_b_1() { String queryString = "CONSTRUCT { ?s ?p ?o GRAPH ?g1 { ?s1 ?p1 ?o1 } } WHERE { ?s ?p ?o. GRAPH ?g1 { ?s1 ?p1 ?o1 } }"; Query q = QueryFactory.create(queryString, Syntax.syntaxARQ); QueryExecution qExec = QueryExecutionFactory.create(q, d); Iterator<Triple> ts = qExec.execConstructTriples(); Model result = ModelFactory.createDefaultModel(); while (ts.hasNext()) { Triple t = ts.next(); Statement stmt = ModelUtils.tripleToStatement(result, t); if ( stmt != null ) result.add(stmt); } assertEquals(1, result.size()); assertTrue(dft.isIsomorphicWith(result)); }
Iterator<Triple> it = qe.execConstructTriples(); result = SPARQLResultEx.createTriples(it); } else if (q.isSelectType()) {