Package org.openrdf.query

Examples of org.openrdf.query.Query


  @Override
  public BooleanResult getBooleanResult()
    throws ResourceException
  {
    Query query = RequestAtt.getQuery(getRequest());

    if (query == null) {
      // query is expected to be available in the request attributes
      throw new ResourceException(SERVER_ERROR_INTERNAL, "missing query attribute");
    }

    if (!(query instanceof BooleanQuery)) {
      throw new ResourceException(SERVER_ERROR_INTERNAL, "unexpected query type: "
          + query.getClass().getName());
    }

    try {
      return ((BooleanQuery)query).evaluate();
    }
View Full Code Here


  @Override
  protected Representation getRepresentation(RDFWriterFactory service, MediaType mediaType)
    throws ResourceException
  {
    Query query = RequestAtt.getQuery(getRequest());

    if (query == null) {
      // query is expected to be available in the request attributes
      throw new ResourceException(SERVER_ERROR_INTERNAL, "missing query attribute");
    }

    if (!(query instanceof GraphQuery)) {
      throw new ResourceException(SERVER_ERROR_INTERNAL, "unexpected query type: "
          + query.getClass().getName());
    }

    try {
      GraphResult queryResult = ((GraphQuery)query).evaluate();
      return new ModelResultRepresentation(queryResult, service, mediaType);
View Full Code Here

    String queryStr = request.getParameter(QUERY_PARAM_NAME);
    logger.debug("query = {}", queryStr);

    if (queryStr != null) {
      Query query = getQuery(repository, repositoryCon, queryStr, request, response);

      View view;
      Object queryResult;
      FileFormatServiceRegistry<? extends FileFormat, ?> registry;

      if (query instanceof TupleQuery) {
        TupleQuery tQuery = (TupleQuery)query;

        queryResult = tQuery.evaluate();
        registry = TupleQueryResultWriterRegistry.getInstance();
        view = TupleQueryResultView.getInstance();
      }
      else if (query instanceof GraphQuery) {
        GraphQuery gQuery = (GraphQuery)query;

        queryResult = gQuery.evaluate();
        registry = RDFWriterRegistry.getInstance();
        view = GraphQueryResultView.getInstance();
      }
      else if (query instanceof BooleanQuery) {
        BooleanQuery bQuery = (BooleanQuery)query;

        queryResult = bQuery.evaluate();
        registry = BooleanQueryResultWriterRegistry.getInstance();
        view = BooleanQueryResultView.getInstance();
      }
      else {
        throw new ClientHTTPException(SC_BAD_REQUEST, "Unsupported query type: "
            + query.getClass().getName());
      }

      Object factory = ProtocolUtil.getAcceptableService(request, response, registry);

      Map<String, Object> model = new HashMap<String, Object>();
View Full Code Here

  private Query getQuery(Repository repository, RepositoryConnection repositoryCon, String queryStr,
      HttpServletRequest request, HttpServletResponse response)
    throws IOException, ClientHTTPException
  {
    Query result = null;

    // default query language is SPARQL
    QueryLanguage queryLn = QueryLanguage.SPARQL;

    String queryLnStr = request.getParameter(QUERY_LANGUAGE_PARAM_NAME);
    logger.debug("query language param = {}", queryLnStr);

    if (queryLnStr != null) {
      queryLn = QueryLanguage.valueOf(queryLnStr);

      if (queryLn == null) {
        throw new ClientHTTPException(SC_BAD_REQUEST, "Unknown query language: " + queryLnStr);
      }
    }

    // determine if inferred triples should be included in query evaluation
    boolean includeInferred = ProtocolUtil.parseBooleanParam(request, INCLUDE_INFERRED_PARAM_NAME, true);

    // build a dataset, if specified
    String[] defaultGraphURIs = request.getParameterValues(DEFAULT_GRAPH_PARAM_NAME);
    String[] namedGraphURIs = request.getParameterValues(NAMED_GRAPH_PARAM_NAME);

    DatasetImpl dataset = null;
    if (defaultGraphURIs != null || namedGraphURIs != null) {
      dataset = new DatasetImpl();

      if (defaultGraphURIs != null) {
        for (String defaultGraphURI : defaultGraphURIs) {
          try {
            URI uri = repository.getValueFactory().createURI(defaultGraphURI);
            dataset.addDefaultGraph(uri);
          }
          catch (IllegalArgumentException e) {
            throw new ClientHTTPException(SC_BAD_REQUEST, "Illegal URI for default graph: "
                + defaultGraphURI);
          }
        }
      }

      if (namedGraphURIs != null) {
        for (String namedGraphURI : namedGraphURIs) {
          try {
            URI uri = repository.getValueFactory().createURI(namedGraphURI);
            dataset.addNamedGraph(uri);
          }
          catch (IllegalArgumentException e) {
            throw new ClientHTTPException(SC_BAD_REQUEST, "Illegal URI for named graph: "
                + namedGraphURI);
          }
        }
      }
    }

    try {
      result = repositoryCon.prepareQuery(queryLn, queryStr);
      result.setIncludeInferred(includeInferred);

      if (dataset != null) {
        result.setDataset(dataset);
      }

      // determine if any variable bindings have been set on this query.
      @SuppressWarnings("unchecked")
      Enumeration<String> parameterNames = request.getParameterNames();

      while (parameterNames.hasMoreElements()) {
        String parameterName = parameterNames.nextElement();

        if (parameterName.startsWith(BINDING_PREFIX) && parameterName.length() > BINDING_PREFIX.length())
        {
          String bindingName = parameterName.substring(BINDING_PREFIX.length());
          Value bindingValue = ProtocolUtil.parseValueParam(request, parameterName,
              repository.getValueFactory());
          result.setBinding(bindingName, bindingValue);
        }
      }
    }
    catch (UnsupportedQueryLanguageException e) {
      ErrorInfo errInfo = new ErrorInfo(ErrorType.UNSUPPORTED_QUERY_LANGUAGE, queryLn.getName());
View Full Code Here

    throws Exception
  {
    RepositoryConnection con = dataRep.getConnection();
    try {
      String queryString = readQueryString();
      Query query = con.prepareQuery(QueryLanguage.SPARQL, queryString, queryFileURL);
      if (dataset != null) {
        query.setDataset(dataset);
      }

      if (query instanceof TupleQuery) {
        TupleQueryResult queryResult = ((TupleQuery)query).evaluate();

        TupleQueryResult expectedResult = readExpectedTupleQueryResult();
        compareTupleQueryResults(queryResult, expectedResult);

        // Graph queryGraph = RepositoryUtil.asGraph(queryResult);
        // Graph expectedGraph = readExpectedTupleQueryResult();
        // compareGraphs(queryGraph, expectedGraph);
      }
      else if (query instanceof GraphQuery) {
        GraphQueryResult gqr = ((GraphQuery)query).evaluate();
        Set<Statement> queryResult = Iterations.asSet(gqr);

        Set<Statement> expectedResult = readExpectedGraphQueryResult();

        compareGraphs(queryResult, expectedResult);
      }
      else if (query instanceof BooleanQuery) {
        boolean queryResult = ((BooleanQuery)query).evaluate();
        boolean expectedResult = readExpectedBooleanQueryResult();
        assertEquals(expectedResult, queryResult);
      }
      else {
        throw new RuntimeException("Unexpected query type: " + query.getClass());
      }
    }
    finally {
      con.close();
    }
View Full Code Here

    RepositoryConnection conn = null;
    String query = request.getParameter("query");
   
    try {
      conn = dataRepository.getConnection();
      Query q = conn.prepareQuery(QueryLanguage.SPARQL, query);
     
      if (q instanceof TupleQuery) {
        /* <code>SELECT</code> form */
        response.setContentType("application/sparql-results+xml");
        SPARQLResultsXMLWriter sparqlWriter = new SPARQLResultsXMLWriter(outputStream);
View Full Code Here

        });
    }

    @Override
    public Query parseQuery(QueryLanguage language, String query) throws RepositoryException, MalformedQueryException {
        Query sparqlQuery = null;
        RepositoryConnection connection = sesameService.getConnection();
        try {
            connection.begin();
            sparqlQuery = connection.prepareQuery(language, query);
            connection.commit();
View Full Code Here

                long start = System.currentTimeMillis();
                try {
                    RepositoryConnection connection = sesameService.getConnection();
                    try {
                        connection.begin();
                        Query sparqlQuery = connection.prepareQuery(queryLanguage, query);

                        if (sparqlQuery instanceof TupleQuery) {
                            query((TupleQuery) sparqlQuery, tupleWriter);
                        } else if (sparqlQuery instanceof BooleanQuery) {
                            query((BooleanQuery) sparqlQuery, booleanWriter);
                        } else if (sparqlQuery instanceof GraphQuery) {
                            query((GraphQuery) sparqlQuery, graphWriter);
                        } else {
                            connection.rollback();
                            throw new InvalidArgumentException("SPARQL query type " + sparqlQuery.getClass() + " not supported!");
                        }

                        connection.commit();
                    } catch (Exception ex) {
                        connection.rollback();
View Full Code Here

                long start = System.currentTimeMillis();
                try {
                    RepositoryConnection connection = sesameService.getConnection();
                    try {
                        connection.begin();
                        Query sparqlQuery = connection.prepareQuery(language, query);

                        if (sparqlQuery instanceof TupleQuery) {
                            query((TupleQuery)sparqlQuery, output, format);
                        } else if (sparqlQuery instanceof BooleanQuery) {
                            query((BooleanQuery)sparqlQuery, output, format);
                        } else if (sparqlQuery instanceof GraphQuery) {
                            query((GraphQuery)sparqlQuery, output, format);
                        } else {
                            throw new InvalidArgumentException("SPARQL query type " + sparqlQuery.getClass() + " not supported!");
                        }

                        connection.commit();
                    } catch (Exception ex) {
                        connection.rollback();
View Full Code Here

        });
    }

    @Override
    public Query parseQuery(QueryLanguage language, String query) throws RepositoryException, MalformedQueryException {
        Query sparqlQuery = null;
        RepositoryConnection connection = sesameService.getConnection();
        try {
            connection.begin();
            sparqlQuery = connection.prepareQuery(language, query);
            connection.commit();
View Full Code Here

TOP

Related Classes of org.openrdf.query.Query

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.