/** * Create a QueryBuilder for creating a select query * * @return a select QueryBuilder */ public static QueryBuilder<ParsedTupleQuery> select() { return new AbstractQueryBuilder<ParsedTupleQuery>(new ParsedTupleQuery()); }
/** * Creates a new {@link MongoPcjQueryNode}. * * @param sparql - sparql query whose results will be stored in PCJ document. (not empty of null) * @param pcjId - name of an existing PCJ. (not empty or null) * @param pcjDocs - {@link MongoPcjDocuments} used to maintain PCJs in mongo. (not null) * * @throws MalformedQueryException - The SPARQL query needs to contain a projection. */ public MongoPcjQueryNode(final String sparql, final String pcjId, final MongoPcjDocuments pcjDocs) throws MalformedQueryException { checkArgument(!Strings.isNullOrEmpty(sparql)); checkArgument(!Strings.isNullOrEmpty(pcjId)); this.pcjDocs = checkNotNull(pcjDocs); this.pcjId = pcjId; final SPARQLParser sp = new SPARQLParser(); final ParsedTupleQuery pq = (ParsedTupleQuery) sp.parseQuery(sparql, null); final TupleExpr te = pq.getTupleExpr(); Preconditions.checkArgument(PCJOptimizerUtilities.isPCJValid(te), "TupleExpr is an invalid PCJ."); final Optional<Projection> projection = new ParsedQueryUtil().findProjection(pq); if (!projection.isPresent()) { throw new MalformedQueryException("SPARQL query '" + sparql + "' does not contain a Projection."); } setProjectionExpr(projection.get()); }
private ParsedTupleTemplate(Template template, ParsedTupleQuery query, BindingSet args) { super(query.getSourceString(), query.getTupleExpr()); setDataset(query.getDataset()); this.template = template; this.args = args; }
/** * Returns a <tt>SelectQuery</tt> for the specified SPARQL SELECT query string. * * @param string * the query string, in SPARQL and without relative URIs * @return the corresponding <tt>SelectQuery</tt> * @throws ParseException * in case the string does not denote a valid SPARQL SELECT query */ public static SelectQuery from(final String string) throws ParseException { Preconditions.checkNotNull(string); SelectQuery query = CACHE.getIfPresent(string); if (query == null) { final ParsedTupleQuery parsedQuery; try { parsedQuery = QueryParserUtil.parseTupleQuery(QueryLanguage.SPARQL, string, null); } catch (final IllegalArgumentException ex) { throw new ParseException(string, "SPARQL query not in SELECT form", ex); } catch (final MalformedQueryException ex) { throw new ParseException(string, "Invalid SPARQL query: " + ex.getMessage(), ex); } query = new SelectQuery(string, parsedQuery.getTupleExpr(), parsedQuery.getDataset()); CACHE.put(string, query); } return query; }
parsedQuery = new ParsedTupleQuery(root); if(queryResult.hasNext()) { BindingSet bs = queryResult.next(); Set<String> bindingNames = tupleQuery.getTupleExpr().getBindingNames(); if(!bindingNames.isEmpty()) { result = bs.getValue(bindingNames.iterator().next());
public void handleTupleQuery(ParsedTupleQuery query) { try { init(); subject = vf.createBNode(); handleType(SeRQO.TUPLEQUERY); handleChild(SeRQO.TUPLEEXPR, query.getTupleExpr()); rdf.endRDF(); } catch (RDFHandlerException e) { throw new UndeclaredThrowableException(e); } }
/** * Create a QueryBuilder for creating a select query * * @param theProjectionVars * the list of elements in the projection of the query * @return a select query builder */ public static QueryBuilder<ParsedTupleQuery> select(String... theProjectionVars) { QueryBuilder<ParsedTupleQuery> aBuilder = new AbstractQueryBuilder<ParsedTupleQuery>( new ParsedTupleQuery()); aBuilder.addProjectionVar(theProjectionVars); return aBuilder; }
public void render(ParsedTupleQuery query, RDFHandler handler) throws RDFHandlerException { handler.startRDF(); Resource querySubj = valueFactory.createBNode(); handler.handleStatement(valueFactory.createStatement(querySubj, RDF.TYPE, SP.SELECT_CLASS)); if (output.text) { handler.handleStatement(valueFactory.createStatement(querySubj, SP.TEXT_PROPERTY, valueFactory.createLiteral(query.getSourceString()))); } if (output.rdf) { TupleExpr expr = query.getTupleExpr(); SpinVisitor visitor = new SpinVisitor(handler, null, querySubj, query.getDataset()); expr.visit(visitor); visitor.end(); } handler.endRDF(); }
protected int countQueryResults(String query) throws Exception { ParsedTupleQuery tupleQuery = QueryParserUtil.parseTupleQuery(QueryLanguage.SERQL, query + " using namespace ex = <" + EXAMPLE_NS + ">", null); return countElements(con.evaluate(tupleQuery.getTupleExpr(), null, EmptyBindingSet.getInstance(), false)); }
public void handleStatement(Statement st) throws RDFHandlerException { Resource subj = st.getSubject(); URI pred = st.getPredicate(); Value obj = st.getObject(); if (pred.equals(RDF.TYPE)) { Object o; if (obj.equals(SeRQO.TUPLEQUERY)) { o = query = new ParsedTupleQuery(); } else if (obj.equals(SeRQO.GRAPHQUERY)) { o = query = new ParsedGraphQuery(statements.getNamespaces()); } else if (obj.equals(RDF.SEQ)) { o = new ArrayList(); } else { o = createNode((URI) obj); } model.put(subj, o); } else { statements.handleStatement(st); } }
@Override public TupleQueryResult evaluate() throws QueryEvaluationException { TupleExpr tupleExpr = getParsedQuery().getTupleExpr(); CloseableIteration<? extends BindingSet, QueryEvaluationException> bindingsIter; bindingsIter = AbstractQueryPreparer.this.evaluate(tupleExpr, getActiveDataset(), getBindings(), getIncludeInferred(), getMaxExecutionTime()); bindingsIter = enforceMaxQueryTime(bindingsIter); return new TupleQueryResultImpl(new ArrayList<String>(tupleExpr.getBindingNames()), bindingsIter); }
/** * Creates a new query based on a tuple expression and original query. The * new query will have the same type null * ({@link org.openrdf.query.TupleQuery}, * {@link org.openrdf.query.GraphQuery} or * {@link org.openrdf.query.BooleanQuery}) as the given original query. * * @param orig the original query * @param expr the expression used for the new query * @return new query based on expression */ protected Query getExprQuery(ParsedQuery orig, TupleExpr expr) { if (orig instanceof ParsedTupleQuery) { return new SailTupleExprQuery( new ParsedTupleQuery(expr), conn); } else if (orig instanceof ParsedGraphQuery) { return new SailGraphExprQuery( new ParsedGraphQuery(expr), conn); } else { return new SailBooleanExprQuery( new ParsedBooleanQuery(expr), conn); } } }
@Override public TupleQueryResult evaluate() throws QueryEvaluationException { TupleExpr tupleExpr = getParsedQuery().getTupleExpr(); try { CloseableIteration<? extends BindingSet, QueryEvaluationException> bindingsIter; SailConnection sailCon = getSailConnection(); bindingsIter = sailCon.evaluate(tupleExpr, getActiveDataset(), getBindings(), getIncludeInferred()); bindingsIter = enforceMaxQueryTime(bindingsIter); return new TupleQueryResultImpl(new ArrayList<String>(tupleExpr.getBindingNames()), bindingsIter); } catch (SailException e) { throw new QueryEvaluationException(e.getMessage(), e); } }
/** * Converts a {@link Filter} to a SPARQL query containing only the SPARQL representation * of the Filter along with a Select clause that return all variables. The argument of the * Filter is replaced by a {@link SingletonSet} so that the body of the SPARQL query consists of only a * single Filter clause. * @param filter - Filter to be serialized * @return - SPARQL String containing a single Filter clause that represents the serialized Filter * @throws FilterParseException */ public static String serialize(Filter filter) throws FilterParseException { Filter clone = filter.clone(); clone.setArg(new SingletonSet()); try { return removeAngularBracketsFromNonUriFunctions(renderer.render(new ParsedTupleQuery(clone))); } catch (Exception e) { throw new FilterParseException("Unable to parse Filter.", e); } }
@Override public TupleQueryResult evaluate() throws QueryEvaluationException { TupleExpr tupleExpr = getParsedQuery().getTupleExpr(); try { CloseableIteration<? extends BindingSet, QueryEvaluationException> bindingsIter; SailConnection sailCon = getConnection().getSailConnection(); bindingsIter = sailCon.evaluate(tupleExpr, getActiveDataset(), getBindings(), getIncludeInferred()); bindingsIter = enforceMaxQueryTime(bindingsIter); return new IteratingTupleQueryResult(new ArrayList<String>(tupleExpr.getBindingNames()), bindingsIter); } catch (SailException e) { throw new QueryEvaluationException(e.getMessage(), e); } }
String exprString; try { exprString = new SPARQLQueryRenderer().render(new ParsedTupleQuery(stmts)); exprString = exprString.substring(exprString.indexOf('{') + 1, exprString.lastIndexOf('}'));
final SPARQLParser sp = new SPARQLParser(); final ParsedTupleQuery pq = (ParsedTupleQuery) sp.parseQuery(sparql, null); final TupleExpr te = pq.getTupleExpr(); Preconditions.checkArgument(PCJOptimizerUtilities.isPCJValid(te), "TupleExpr is an invalid PCJ.");
SesameRDFVisitor visitor = new SesameRDFVisitor(dialect); TupleExpr tuple = visitor.visit((QueryMetadata) definition, queryLanguage); ParsedTupleQuery queryModel = new ParsedTupleQuery(tuple); TupleQuery query = DirectQuery.getQuery(connection, queryModel, queryInference); return (Q) new TupleQueryImpl(query, dialect);
/*** * Takes a SELECT query and * @param query */ public void unfold(ParsedTupleQuery query) { ResolutionVisitor visitor = new ResolutionVisitor(rules); TupleExpr body = query.getTupleExpr(); VarNameCollector collector = new VarNameCollector(); body.visit(collector); Set<String> bindingNames = collector.getVarNames(); visitor.setBindingNames(bindingNames); body.visit(visitor); while (visitor.producedChange) { visitor.producedChange = false; body.visit(visitor); } }
final ASTQuery queryNode = qc.getQuery(); if (queryNode instanceof ASTSelectQuery) { query = new ParsedTupleQuery(string, tupleExpr); } else if (queryNode instanceof ASTConstructQuery) { query = new ParsedGraphQuery(string, tupleExpr, prefixes);