Java Code Examples for org.eclipse.rdf4j.query.BooleanQuery#evaluate()

@Override
public boolean ask(Service service, BindingSet bindings, String baseUri) throws QueryEvaluationException {
	RepositoryConnection conn = endpoint.getConn();
	try {
		BooleanQuery query = conn.prepareBooleanQuery(QueryLanguage.SPARQL, service.getAskQueryString(), baseUri);
		Iterator<Binding> bIter = bindings.iterator();
		while (bIter.hasNext()) {
			Binding b = bIter.next();
			if (service.getServiceVars().contains(b.getName()))
				query.setBinding(b.getName(), b.getValue());
		}
		return query.evaluate();
	} catch(Throwable e) {
		throw new QueryEvaluationException(e);
	} finally {
		conn.close();
	}
}
 

@Override
public boolean hasStatements(ExclusiveTupleExpr group, BindingSet bindings)
		throws RepositoryException, MalformedQueryException,
		QueryEvaluationException {

	monitorRemoteRequest();
	String preparedAskQuery = QueryStringUtil.askQueryString(group, bindings, group.getQueryInfo().getDataset());
	try (RepositoryConnection conn = endpoint.getConnection()) {
		BooleanQuery query = conn.prepareBooleanQuery(QueryLanguage.SPARQL, preparedAskQuery);
		configureInference(query, group.getQueryInfo());
		applyMaxExecutionTimeUpperBound(query);
		return query.evaluate();
	}
}
 

@Test
public void testPrepareBooleanQuery_not_bypassed() throws Exception {
	Optional<TupleExpr> response = Optional.empty();
	when(sailConnection.prepareQuery(any(), eq(Query.QueryType.BOOLEAN), any(), any())).thenReturn(response);
	when(sailConnection.evaluate(any(), any(), any(), anyBoolean())).thenReturn(new EmptyIteration<>());

	BooleanQuery query = subject.prepareBooleanQuery("ASK WHERE { ?s ?p ?o }");
	query.evaluate();
	// check that evaluation is still called, and not with an empty TupleExpr
	verify(sailConnection).evaluate(any(TupleExpr.class), any(), any(), anyBoolean());
}
 

@Test
public void testPrepareBooleanQuery_bypassed() throws Exception {
	TupleExpr expr = mock(TupleExpr.class);
	Optional<TupleExpr> response = Optional.of(expr);
	when(sailConnection.prepareQuery(any(), eq(Query.QueryType.BOOLEAN), any(), any())).thenReturn(response);
	when(sailConnection.evaluate(eq(expr), any(), any(), anyBoolean())).thenReturn(new EmptyIteration<>());

	BooleanQuery query = subject.prepareBooleanQuery("ASK WHERE { ?s ?p ?o }");
	query.evaluate();
	// check that the TupleExpr implementation created by the underlying sail was passed to the evaluation
	verify(sailConnection).evaluate(eq(expr), any(), any(), anyBoolean());
}
 

@Override
public boolean isEmpty() throws RepositoryException {
	try {
		BooleanQuery query;
		if (isQuadMode()) {
			query = prepareBooleanQuery(SPARQL, SOMETHING_WITH_GRAPH);
		} else {
			query = prepareBooleanQuery(SPARQL, SOMETHING);
		}
		return !query.evaluate();
	} catch (MalformedQueryException | QueryEvaluationException e) {
		throw new RepositoryException(e);
	}
}
 

@Override
public boolean hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
		throws RepositoryException {
	try {
		BooleanQuery query = prepareBooleanQuery(SPARQL, SOMETHING, "");
		setBindings(query, subj, pred, obj, contexts);
		return query.evaluate();
	} catch (MalformedQueryException | QueryEvaluationException e) {
		throw new RepositoryException(e);
	}
}
 

protected void renderInternal(Map model, HttpServletRequest request, HttpServletResponse response) throws IOException {
    BooleanQueryResultWriterFactory brWriterFactory = (BooleanQueryResultWriterFactory)model.get("factory");
    BooleanQueryResultFormat brFormat = brWriterFactory.getBooleanQueryResultFormat();
    response.setStatus(200);
    this.setContentType(response, brFormat);
    this.setContentDisposition(model, response, brFormat);
    boolean headersOnly = ((Boolean)model.get("headersOnly")).booleanValue();
    if(!headersOnly) {
        ServletOutputStream out = response.getOutputStream();

        try {
            BooleanQueryResultWriter e = brWriterFactory.getWriter(out);
            BooleanQuery query = ((BooleanQuery)model.get("queryResult"));
            boolean value = query.evaluate();
            e.handleBoolean(value);
        } catch (QueryResultHandlerException var13) {
            if(var13.getCause() != null && var13.getCause() instanceof IOException) {
                throw (IOException)var13.getCause();
            }

            throw new IOException(var13);
        } finally {
            out.close();
        }
    }

    this.logEndOfRequest(request);
}
 

@Override
public boolean sparqlAsk(String query) throws ModelRuntimeException {
	assertModel();
	try {
		BooleanQuery prepared = this.connection.prepareBooleanQuery(QueryLanguage.SPARQL, query);
		return prepared.evaluate();
	} catch (MalformedQueryException | RepositoryException |
			UnsupportedQueryLanguageException | QueryEvaluationException e) {
		throw new ModelRuntimeException(e);
	}
}
 

@Override
public boolean sparqlAsk(String queryString) throws ModelRuntimeException {
	this.assertModel();
	BooleanQuery booleanQuery;
	try {
		booleanQuery = this.connection.prepareBooleanQuery(QueryLanguage.SPARQL, queryString);
		boolean result = booleanQuery.evaluate();
		return result;
	} catch(RDF4JException e) {
		throw new ModelRuntimeException(e);
	}
}
 

private void evaluateBooleanQuery(final TupleResultBuilder builder, final BooleanQuery query)
		throws QueryEvaluationException, QueryResultHandlerException {
	final boolean result = query.evaluate();
	builder.link(Arrays.asList(INFO));
	builder.bool(result);
}