How to use

org.openrdf.query.parser.sparql.SPARQLParser

constructor

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);
  }
}

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

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

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

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

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

try {
  sparqlQuery = getPrefixes() + sparqlQuery;
  final SPARQLParser parser = new SPARQLParser();
  final ParsedQuery query = parser.parseQuery(sparqlQuery, null);
  boolean includeInferred = false;

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!");
  }
}

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();

final SPARQLParser parser = new SPARQLParser();
final ParsedQuery parsedQuery = parser.parseQuery(sparql, null);

final SPARQLParser parser = new SPARQLParser();
final SPARQLQueryRenderer renderer = new SPARQLQueryRenderer();
final ParsedQuery pq = parser.parseQuery(metadata.getSparql(), null);

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

@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);
  }
}

final SPARQLParser parser = new SPARQLParser();
ParsedQuery pq;
try {