import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Override
   public Response toResponse(QueryParseException ex)
   {
       return com.atomgraph.core.model.impl.Response.fromRequest(getRequest()).
               getResponseBuilder(toResource(ex, Response.Status.INTERNAL_SERVER_ERROR,
                       ResourceFactory.createResource("http://www.w3.org/2011/http-statusCodes#InternalServerError")).
                   getModel(), getVariants()).
               status(Response.Status.INTERNAL_SERVER_ERROR).
               build();

       /*
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).
               entity(toResource(ex, Response.Status.INTERNAL_SERVER_ERROR,
                       ResourceFactory.createResource("http://www.w3.org/2011/http-statusCodes#InternalServerError")).
                   getModel()).
	build();
       */
   }
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Override
public Response toResponse(final QueryParseException e) {

    LOGGER.error("Captured a query parse exception {}", e.getMessage());
    debugException(this, e, LOGGER);
    if (e.getMessage().matches(".* Unresolved prefixed name: .*")) {
        final Pattern namespacePattern =
            Pattern.compile("Unresolved prefixed name: (\\w+:\\w+)");
        final Matcher namespaceMatch =
            namespacePattern.matcher(e.getMessage());
        if (namespaceMatch.find()) {
            final String msg =
                String.format(
                    "There are one or more undefined namespace(s) in your request [ %s ], " +
                    "please define them before retrying",
                    namespaceMatch.group(1));
            return status(BAD_REQUEST).entity(msg).type(TEXT_PLAIN_WITH_CHARSET).build();
        }
    }

    return status(BAD_REQUEST).entity(e.getMessage()).type(TEXT_PLAIN_WITH_CHARSET).build();
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
/**
 * A factory that creates a {@link RootPlan} from a SPARQL-Generate query.
 *
 * @param queryStr the string representation of the SPARQL-Generate query.
 * @return the RootPlan that may be used to execute the SPARQL-Generate
 * query.
 */
public static final RootPlan create(final String queryStr) {
    Objects.requireNonNull(queryStr, "Parameter string must not be null");
    SPARQLGenerateQuery query;
    try {
        query = (SPARQLGenerateQuery) QueryFactory.create(queryStr,
                SPARQLGenerate.SYNTAX);
    } catch (QueryParseException ex) {
        throw new SPARQLGenerateException(
                "Error while parsing the query \n" + queryStr, ex);
    }
    LOG.trace("Creating plan for query: \n" + query);
    return create(query);
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
protected AbstractSPARQLExecutor(Constraint constraint) {
	this.queryString = getSPARQL(constraint);
	try {
		this.query = ARQFactory.get().createQuery(queryString);
	}
	catch(QueryParseException ex) {
		throw new SHACLException("Invalid SPARQL constraint (" + ex.getLocalizedMessage() + "):\n" + queryString);
	}

	if(!query.isSelectType()) {
		throw new IllegalArgumentException("SHACL constraints must be SELECT queries");
	}
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
/**
 * Attempts to parse a given string into a Jena Path.
 * Throws an Exception if the string cannot be parsed.
 * @param string  the string to parse
 * @param model  the Model to operate on (for prefixes)
 * @return a Path or a Resource if this is a URI
 */
public static Object getJenaPath(String string, Model model) throws QueryParseException {
	Query query = ARQFactory.get().createQuery(model, "ASK { ?a \n" + string + "\n ?b }");
	Element element = query.getQueryPattern();
	if(element instanceof ElementGroup) {
		Element e = ((ElementGroup)element).getElements().get(0);
		if(e instanceof ElementPathBlock) {
			return ((ElementPathBlock) e).getPattern().get(0).getPath();
		}
		else if(e instanceof ElementTriplesBlock) {
			return model.asRDFNode(((ElementTriplesBlock) e).getPattern().get(0).getPredicate());
		}
	}
	throw new QueryParseException("Not a SPARQL 1.1 Path expression", 2, 1);
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Test
public void testInvalidNamespace() {
    final QueryParseException input = new QueryParseException(
        "Unresolved prefixed name: invalidNS:title", 14, 10);
    final Response actual = testObj.toResponse(input);
    assertEquals(BAD_REQUEST.getStatusCode(), actual.getStatus());
    assertEquals(actual.getEntity(), input.getMessage());
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Test
public void testToResponse() {
    final QueryParseException input = new QueryParseException("An error occurred", 14, 10);
    final Response actual = testObj.toResponse(input);
    assertEquals(BAD_REQUEST.getStatusCode(), actual.getStatus());
    assertNotNull(actual.getEntity());
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Override
public Query getSparqlQuery(TestCase testCase) {
    String query = this.getSparqlQueryAsString(testCase);
    try {
        return QueryFactory.create(query);
    } catch (QueryParseException e) {
        throw new IllegalArgumentException("Illegal query: \n" + query, e);
    }
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
private void validateSPARQL(String sparql, String type)  {
    try {
        QueryFactory.create(sparql);
    } catch (QueryParseException e) {
        String message = "QueryParseException in " + type + " query (line " + e.getLine() + ", column " + e.getColumn() + " for Test: " + testCase.getTestURI() + "\n" + PrefixNSService.getSparqlPrefixDecl() + sparql;
        //throw new TestCaseInstantiationException(message, e);
        log.warn(message,e);
    }
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
private void parseDo(SPARQLParser11 parser) throws ParseException {
	do {
		int beginLine = parser.getToken(1).beginLine;
		int beginColumn = parser.getToken(1).beginColumn;

		Query query = new Query(result.getPrologue());

		// You'd assume that a query initialized via "new Query(prologue)"
		// has the IRI resolver from prologue.getResolver(), but that doesn't
		// appear to be the case in Jena 2.12.0, so we set it manually
		query.getPrologue().setResolver(result.getPrologue().getResolver());

		result.addQuery(query);
		parser.setQuery(query);
		parser.Query();

		if (query.isSelectType() || query.isAskType()) {
			seenSelectOrAsk = true;
		}
		if (seenSelectOrAsk && result.getQueries().size() > 1) {
			throw new QueryParseException("" +
					"Multiple queries per file are only supported for CONSTRUCT", 
					beginLine, beginColumn);
		}
		
		// From Parser.validateParsedQuery, which we can't call directly
		SyntaxVarScope.check(query);
		
		result.getPrologue().usePrologueFrom(query);
		if (log.isDebugEnabled()) {
			log.debug(query.toString());
		}
	} while (parser.getToken(1).kind != SPARQLParser11.EOF);
	removeTarqlPrefix();
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Test
public void testMultipleSELECT() throws Exception {
	try {
		String s = "SELECT * {} SELECT * {}";
		TarqlParser x = new TarqlParser(new StringReader(s));
		x.getResult().getQueries();
		fail("Expected exception due to multiple queries");
	} catch (QueryParseException ex) {
		// Expected
	}
}
 

import org.apache.jena.query.QueryParseException; //导入依赖的package包/类
@Test
public void testSELECTAndCONSTRUCT() throws Exception {
	try {
		String s = "CONSTRUCT { [] a [] } WHERE {} SELECT * {}";
		TarqlParser x = new TarqlParser(new StringReader(s));
		x.getResult().getQueries();
		fail("Expected exception due to multiple queries");
	} catch (QueryParseException ex) {
		// Expected
	}
}