Java Code Examples for org.eclipse.rdf4j.query.QueryLanguage#SPARQL

/**
 * Save a query. UNSAFE from an injection point of view. It is the responsibility of the calling code to call
 * checkAccess() with the full credentials first.
 *
 * @param repository    the repository the query is associated with
 * @param queryName     the name for the query
 * @param userName      the user saving the query
 * @param shared        whether the query is to be shared with other users
 * @param queryLanguage the language, SeRQL or SPARQL, of the query
 * @param queryText     the actual query text
 * @param infer
 * @param rowsPerPage   rows to display per page, may be 0 (all), 10, 50, 100, or 200)
 * @throws RDF4JException
 */
public void saveQuery(final HTTPRepository repository, final String queryName, final String userName,
		final boolean shared, final QueryLanguage queryLanguage, final String queryText, final boolean infer,
		final int rowsPerPage) throws RDF4JException {
	if (QueryLanguage.SPARQL != queryLanguage && QueryLanguage.SERQL != queryLanguage) {
		throw new RepositoryException("May only save SPARQL or SeRQL queries, not" + queryLanguage.toString());
	}
	if (0 != rowsPerPage && 10 != rowsPerPage && 20 != rowsPerPage && 50 != rowsPerPage && 100 != rowsPerPage
			&& 200 != rowsPerPage) {
		throw new RepositoryException("Illegal value for rows per page: " + rowsPerPage);
	}
	this.checkQueryText(queryText);
	final QueryStringBuilder save = new QueryStringBuilder(SAVE);
	save.replaceURI(REPOSITORY, repository.getRepositoryURL());
	save.replaceURI(QUERY, "urn:uuid:" + UUID.randomUUID());
	save.replaceQuote(QUERY_NAME, queryName);
	this.replaceUpdateFields(save, userName, shared, queryLanguage, queryText, infer, rowsPerPage);
	updateQueryRepository(save.toString());
}
 

private String modifyOffset(final QueryLanguage language, final int offset, final String query) {
	String rval = query;
	final String newOffsetClause = "offset " + offset;
	if (QueryLanguage.SPARQL == language) {
		if (offset > 0) {
			rval = ensureNewlineAndAppend(rval, newOffsetClause);
		}
	} else {
		/*
		 * SeRQL, add the clause before before the namespace section
		 */
		rval = insertAtMatchOnOwnLine(SERQL_NAMESPACE, rval, newOffsetClause);
	}
	return rval;
}
 

private static String modifyLimit(final QueryLanguage language, final String query, final int limitSubstitute) {
	String rval = query;

	/*
	 * In SPARQL, LIMIT and/or OFFSET can occur at the end, in either order. In SeRQL, LIMIT and/or OFFSET must be
	 * immediately prior to the *optional* namespace declaration section (which is itself last), and LIMIT must
	 * precede OFFSET. This code makes no attempt to correct if the user places them out of order in the query.
	 */
	if (QueryLanguage.SPARQL == language) {
		rval = ensureNewlineAndAppend(rval, "limit " + limitSubstitute);
	} else {
		rval = insertAtMatchOnOwnLine(SERQL_NAMESPACE, rval, "limit " + limitSubstitute);
	}
	return rval;
}
 

public static QueryLanguage toRDF4JQueryLanguage(String queryLanguage) {
	String queryLanguageLowerCase = queryLanguage.toLowerCase();

	switch (queryLanguageLowerCase) {
		case "sparql":
			return QueryLanguage.SPARQL;
		case "serql":
			return QueryLanguage.SERQL;
		default:
			throw new QueryLanguageNotSupportedException("Query language '"
					+ queryLanguageLowerCase
					+ "' not supported. Valid values are \"sparql\" and \"serql\".");
	}
}
 

@Override
protected Repository createRepository()
		throws MalformedQueryException, UnsupportedQueryLanguageException, SailException, IOException {
	return new SailRepository(new CustomGraphQueryInferencer(new MemoryStore(), QueryLanguage.SPARQL,
			ResourceUtil.getString("/custom-query-inferencing/rule.rq"),
			ResourceUtil.getString("/custom-query-inferencing/match.rq")));
}
 

public RepositoryQueryResultTable(String queryString, RepositoryConnection connection)
        throws ModelRuntimeException {
	this(queryString, QueryLanguage.SPARQL, connection);
}
 

@Override
public QueryLanguage getQueryLanguage() {
    return QueryLanguage.SPARQL;
}
 

/**
 * @inheritDoc
 */
public QueryLanguage getLanguage() {
    return QueryLanguage.SPARQL;
}
 

public SPARQLBooleanQuery(SparqlSession httpClient, String baseURI,
                          String queryString) {
    super(httpClient, QueryLanguage.SPARQL, queryString, baseURI);
}
 

/**
 * Returns {@link QueryLanguage#SPARQL}.
 */
@Override
public QueryLanguage getQueryLanguage() {
	return QueryLanguage.SPARQL;
}
 

/**
 * @inheritDoc
 */
@Override
public QueryLanguage getLanguage() {
	return QueryLanguage.SPARQL;
}
 

public SPARQLUpdate(SPARQLProtocolSession httpClient, String baseURI, String queryString) {
	super(httpClient, QueryLanguage.SPARQL, queryString, baseURI);
}
 

public SPARQLTupleQuery(SPARQLProtocolSession httpClient, String baseUri, String queryString) {
	super(httpClient, QueryLanguage.SPARQL, queryString, baseUri);
}
 

public SPARQLGraphQuery(SPARQLProtocolSession httpClient, String baseURI, String queryString) {
	super(httpClient, QueryLanguage.SPARQL, queryString, baseURI);
}
 

public SPARQLBooleanQuery(SPARQLProtocolSession httpClient, String baseURI, String queryString) {
	super(httpClient, QueryLanguage.SPARQL, queryString, baseURI);
}
 

/**
 * Check that inner query limits do not affect the paging parameters.
 *
 * @throws IOException
 */
@Test
public final void testSES2307regression() throws IOException {
	PagedQuery pagedQuery = new PagedQuery(ResourceUtil.getString("ses2307.rq"), QueryLanguage.SPARQL, 100, 0);
	assertThat(pagedQuery.getLimit()).isEqualTo(100);
}
 

@Test
public final void testSES1895regression() {
	PagedQuery pagedQuery = new PagedQuery("select * {?s ?p ?o } LIMIT 10", QueryLanguage.SPARQL, 100, 0);
	assertThat(pagedQuery.toString().toLowerCase()).isEqualTo("select * {?s ?p ?o } limit 10");
}