How to use

SPARQLParser

in

org.openrdf.query.parser.sparql

private static ParsedQuery parseQuery(final String query) throws MalformedQueryException {
  SPARQLParser parser = new SPARQLParser();
  return parser.parseQuery(query, BASE_URI);
}

public SparqlQuery(Reader in, String base) throws IOException,
    MalformedQueryException {
  try {
    StringWriter sw = new StringWriter();
    int read;
    char[] cbuf = new char[1024];
    while ((read = in.read(cbuf)) >= 0) {
      sw.write(cbuf, 0, read);
    }
    sparql = sw.toString();
    this.base = base;
    try {
      query = new SPARQLParser().parseQuery(sparql, base);
    } catch (MalformedQueryException e) {
      try {
        query = new SPARQLParser().parseUpdate(sparql, base);
      } catch (MalformedQueryException u) {
        throw e;
      }
    }
  } catch (MalformedQueryException e) {
    logger.warn(base + " " + e.getMessage(), e);
  }
}

  @Override
  public StreamsQuery addQuery(final String query, final boolean isActive) throws RyaStreamsException {
    requireNonNull(query);

    // Make sure the SPARQL is valid.
    try {
      parser.parseQuery(query, null);
    } catch (final MalformedQueryException e) {
      throw new RyaStreamsException("Could not add the query because the SPARQL is invalid.", e);
    }

    // If it is, then store it in the repository.
    return repository.add(query, isActive);
  }
}

TupleExpr tupleExpr = buildQueryModel(qc);

/**
 * Converts a SPARQL query consisting of a single Filter clause back to a Filter.
 * @param sparql - SPARQL query representing a Filter
 * @return - parsed Filter included in the SPARQL query
 * @throws FilterParseException
 */
public static Filter deserialize(String sparql) throws FilterParseException {
  
  try {
    ParsedQuery pq = parser.parseQuery(sparql, null);
    FilterVisitor visitor = new FilterVisitor();
    pq.getTupleExpr().visit(visitor);
    Set<Filter> filters = visitor.getFilters();
    
    if(filters.size() != 1) {
      throw new FilterParseException("Filter String must contain only one Filter.");
    }
    
    return filters.iterator().next();
    
  } catch (Exception e) {
    throw new FilterParseException("Unable to parse Filter.", e);
  }
}

  private String[] prettyFormatSparql(final String sparql) throws Exception {
    final SPARQLParser parser = new SPARQLParser();
    final SPARQLQueryRenderer renderer = new SPARQLQueryRenderer();
    final ParsedQuery pq = parser.parseQuery(sparql, null);
    final String prettySparql = renderer.render(pq);
    final String[] sparqlLines = StringUtils.split(prettySparql, '\n');
    return sparqlLines;
  }
}

public SPARQLQuery(Reader in, String base) throws IOException,
    MalformedQueryException {
  try {
    StringWriter sw = new StringWriter();
    int read;
    char[] cbuf = new char[1024];
    while ((read = in.read(cbuf)) >= 0) {
      sw.write(cbuf, 0, read);
    }
    sparql = sw.toString();
    this.base = base;
    try {
      query = new SPARQLParser().parseQuery(sparql, base);
    } catch (MalformedQueryException e) {
      try {
        query = new SPARQLParser().parseUpdate(sparql, base);
      } catch (MalformedQueryException u) {
        throw e;
      }
    }
  } catch (MalformedQueryException e) {
    throw new MalformedQueryException(base + " " + e.getMessage(), e);
  } finally {
    in.close();
  }
}

private Collection<BindingSet> evaluate(final String queryStr) {
  BindingSet bindings = new EmptyBindingSet();
  String baseURI = "http://example.org/baseUri#";
  ParsedQuery query;
  CloseableIteration<? extends BindingSet, QueryEvaluationException> results;
  query = parser.parseQuery(queryStr, baseURI);
  Collection<BindingSet> coll = new LinkedList<>();
  results = sc.evaluate(query.getTupleExpr(), query.getDataset(), bindings, false);
  try {
    while (results.hasNext()) {
      coll.add(results.next());
    }
  } finally {
    results.close();
  }
  return coll;
}

/**
 * Fetch the {@link StatementPattern} from a SPARQL string.
 *
 * @param sparql - A SPARQL query that contains only a single Statement Patern. (not nul)
 * @return The {@link StatementPattern} that was in the query, if it could be found. Otherwise {@code null}
 * @throws Exception The statement pattern could not be found in the parsed SPARQL query.
 */
public static @Nullable StatementPattern getSp(final String sparql) throws Exception {
  requireNonNull(sparql);
  final AtomicReference<StatementPattern> statementPattern = new AtomicReference<>();
  final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null);
  parsed.getTupleExpr().visitChildren(new QueryModelVisitorBase<Exception>() {
    @Override
    public void meet(final StatementPattern node) throws Exception {
      statementPattern.set(node);
    }
  });
  return statementPattern.get();
}

/**
 * Get the first {@link MultiProjection} node from a SPARQL query.
 *
 * @param sparql - The query that contains a single Projection node.
 * @return The first {@link MultiProjection} that is encountered.
 * @throws Exception The query could not be parsed.
 */
public static @Nullable MultiProjection getMultiProjection(final String sparql) throws Exception {
  requireNonNull(sparql);
  final AtomicReference<MultiProjection> multiProjection = new AtomicReference<>();
  final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null);
  parsed.getTupleExpr().visit(new QueryModelVisitorBase<Exception>() {
    @Override
    public void meet(final MultiProjection node) throws Exception {
      multiProjection.set(node);
    }
  });
  return multiProjection.get();
}

/**
 * Get the first {@link Projection} node from a SPARQL query.
 *
 * @param sparql - The query that contains a single Projection node.
 * @return The first {@link Projection} that is encountered.
 * @throws Exception The query could not be parsed.
 */
public static @Nullable Projection getProjection(final String sparql) throws Exception {
  requireNonNull(sparql);
  final AtomicReference<Projection> projection = new AtomicReference<>();
  final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null);
  parsed.getTupleExpr().visit(new QueryModelVisitorBase<Exception>() {
    @Override
    public void meet(final Projection node) throws Exception {
      projection.set(node);
    }
  });
  return projection.get();
}

private static String getPrettyPrintSparql(String sparql, int indent) throws Exception {
  SPARQLParser parser = new SPARQLParser();
  ParsedQuery pq = parser.parseQuery(sparql, null);
  SPARQLQueryRenderer render = new SPARQLQueryRenderer();
  String renderedQuery = render.render(pq);
  
  //remove extra quotes generated by query renderer
  String[] splitRender = renderedQuery.split("\"\"\"");
  StringBuilder builder = new StringBuilder();
  for(String s: splitRender) {
    builder.append(s).append("\"");
  }
  builder.replace(builder.length() - 1, builder.length(), "");
  
  //add indent to all lines following newline char
  String[] newLineRender = builder.toString().split("\n");
  builder = new StringBuilder();
  String prefix = getVariableIndent(indent);
  for(int i = 0; i < newLineRender.length; i++) {
    if(i != 0) {
      builder.append(prefix);
    }
    builder.append(newLineRender[i]).append("\n");
  }
  
  return builder.toString();
}

  /**
   * Get the first {@link Filter} node from a SPARQL query.
   *
   * @param sparql - The query that contains a single Projection node.
   * @return The first {@link Filter} that is encountered.
   * @throws Exception The query could not be parsed.
   */
  public static @Nullable Filter getFilter(final String sparql) throws Exception {
    requireNonNull(sparql);

    final AtomicReference<Filter> filter = new AtomicReference<>();
    final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null);
    parsed.getTupleExpr().visit(new QueryModelVisitorBase<Exception>() {
      @Override
      public void meet(final Filter node) throws Exception {
        filter.set(node);
      }
    });

    return filter.get();
  }
}

public static Optional<PeriodicQueryNode> getPeriodicNode(String sparql) throws MalformedQueryException {
  TupleExpr te = new SPARQLParser().parseQuery(sparql, null).getTupleExpr();
  PeriodicQueryNodeVisitor periodicVisitor = new PeriodicQueryNodeVisitor();
  te.visit(periodicVisitor);
  return periodicVisitor.getPeriodicNode();
}

/**
 * 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());
}

public CloseableIteration<BindingSet, QueryEvaluationException> queryDocIndex(final String sparqlQuery,
    final Collection<BindingSet> constraints) throws TableNotFoundException, QueryEvaluationException {
  final SPARQLParser parser = new SPARQLParser();
  ParsedQuery pq1 = null;
  try {
    pq1 = parser.parseQuery(sparqlQuery, null);
  } catch (final MalformedQueryException e) {
    e.printStackTrace();
    throw new QueryEvaluationException("Malformed query. query=" + sparqlQuery, e);
  }
  final TupleExpr te1 = pq1.getTupleExpr();
  final List<StatementPattern> spList1 = StatementPatternCollector.process(te1);
  if(StarQuery.isValidStarQuery(spList1)) {
    final StarQuery sq1 = new StarQuery(spList1);
    return queryDocIndex(sq1, constraints);
  } else {
    throw new IllegalArgumentException("Invalid star query!");
  }
}

try {
  sparqlQuery = getPrefixes() + sparqlQuery;
  final SPARQLParser parser = new SPARQLParser();
  final ParsedQuery query = parser.parseQuery(sparqlQuery, null);
  boolean includeInferred = false;
  final CloseableIteration<? extends BindingSet, QueryEvaluationException> results = this.sailConnection.get().evaluate(query.getTupleExpr(), query.getDataset(), new MapBindingSet(), includeInferred);

@Override
public CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluate(final String query)
    throws RippleException {
  ensureOpen();
  SPARQLParser parser = new SPARQLParser();
  boolean useInference = false;
  // FIXME
  String baseIRI = "http://example.org/bogusBaseIRI/";
  ParsedQuery pq;
  try {
    pq = parser.parseQuery(query, baseIRI);
  } catch (MalformedQueryException e) {
    throw new RippleException(e);
  }
  MapBindingSet bindings = new MapBindingSet();
  try {
    return sailConnection.evaluate(pq.getTupleExpr(), pq.getDataset(), bindings, useInference);
  } catch (SailException e) {
    throw new RippleException(e);
  }
}

this.auths = getAuthorizations(conf);
PcjMetadata meta = pcj.getPcjMetadata(accCon, tablename);
final SPARQLParser sp = new SPARQLParser();
final ParsedTupleQuery pq = (ParsedTupleQuery) sp.parseQuery(meta.getSparql(), null);

this.accCon = ConfigUtils.getConnector(conf);
this.auths = getAuthorizations(conf);
final SPARQLParser sp = new SPARQLParser();
final ParsedTupleQuery pq = (ParsedTupleQuery) sp.parseQuery(sparql, null);
final TupleExpr te = pq.getTupleExpr();
Preconditions.checkArgument(PCJOptimizerUtilities.isPCJValid(te),