Beispiel #1
0
  @Test
  public void testSelectAllType() {
    eval =
        new MockSecurityEvaluator(true, true, true, true, true, true) {

          @Override
          public boolean evaluate(
              final Object principal,
              final Action action,
              final Node graphIRI,
              final Triple triple) {
            if (triple.getSubject().isURI()
                && triple.getSubject().getURI().equals("http://example.com/resource/1")) {
              return false;
            }
            return super.evaluate(principal, action, graphIRI, triple);
          }
        };

    setup();

    try {
      String query = "SELECT ?s ?p ?o WHERE " + " { ?s ?p ?o } ";
      QueryExecution qexec = QueryExecutionFactory.create(query, dataset);
      try {
        final ResultSet results = qexec.execSelect();
        int count = 0;
        for (; results.hasNext(); ) {
          count++;
          results.nextSolution();
        }
        // 2x 3 values + type triple
        Assert.assertEquals(8, count);
      } finally {
        qexec.close();
      }

      query = "SELECT ?g ?s ?p ?o WHERE " + " { GRAPH ?g {?s ?p ?o } }";
      qexec = QueryExecutionFactory.create(query, dataset);
      try {
        final ResultSet results = qexec.execSelect();
        int count = 0;
        for (; results.hasNext(); ) {
          count++;
          results.nextSolution();
        }
        // 2x 3 values + type triple
        // all are in the base graph so no named graphs
        Assert.assertEquals(0, count);
      } finally {
        qexec.close();
      }
    } finally {
      dataset.close();
    }
  }
  /**
   * Tests whether a query gives the same results when run both with and without a given optimizer
   *
   * @param queryStr Query
   * @param ds Dataset
   * @param opt Optimizer
   * @param expected Expected number of results
   */
  public static void test(String queryStr, Dataset ds, Symbol opt, int expected) {
    Query q = QueryFactory.create(queryStr);

    if (!q.isSelectType()) Assert.fail("Only SELECT queries are testable with this method");

    Op op = Algebra.compile(q);
    // Track current state
    boolean isEnabled = ARQ.isTrue(opt);
    boolean isDisabled = ARQ.isFalse(opt);

    try {
      // Run first without optimization
      ARQ.set(opt, false);
      ResultSetRewindable rs;
      try (QueryExecution qe = QueryExecutionFactory.create(q, ds)) {
        rs = ResultSetFactory.makeRewindable(qe.execSelect());
        if (expected != rs.size()) {
          System.err.println("Non-optimized results not as expected");
          TextOutput output = new TextOutput((SerializationContext) null);
          output.format(System.out, rs);
          rs.reset();
        }
        Assert.assertEquals(expected, rs.size());
      }

      // Run with optimization
      ARQ.set(opt, true);
      ResultSetRewindable rsOpt;
      try (QueryExecution qeOpt = QueryExecutionFactory.create(q, ds)) {
        rsOpt = ResultSetFactory.makeRewindable(qeOpt.execSelect());
        if (expected != rsOpt.size()) {
          System.err.println("Optimized results not as expected");
          TextOutput output = new TextOutput((SerializationContext) null);
          output.format(System.out, rsOpt);
          rsOpt.reset();
        }
        Assert.assertEquals(expected, rsOpt.size());
      }
      Assert.assertTrue(ResultSetCompare.isomorphic(rs, rsOpt));
    } finally {
      // Restore previous state
      if (isEnabled) {
        ARQ.set(opt, true);
      } else if (isDisabled) {
        ARQ.set(opt, false);
      } else {
        ARQ.unset(opt);
      }
    }
  }
  @Override
  protected QueryExecution createQueryExecution(Query q) throws SQLException {
    if (this.remoteConn.getQueryEndpoint() == null)
      throw new SQLException(
          "This statement is backed by a write-only connection, read operations are not supported");

    // Create basic execution
    QueryEngineHTTP exec =
        (QueryEngineHTTP)
            QueryExecutionFactory.sparqlService(this.remoteConn.getQueryEndpoint(), q);

    // Apply HTTP settings
    if (this.client != null) {
      exec.setClient(this.client);
    }

    // Apply default and named graphs if appropriate
    if (this.remoteConn.getDefaultGraphURIs() != null) {
      exec.setDefaultGraphURIs(this.remoteConn.getDefaultGraphURIs());
    }
    if (this.remoteConn.getNamedGraphURIs() != null) {
      exec.setNamedGraphURIs(this.remoteConn.getNamedGraphURIs());
    }

    // Set result types
    if (this.remoteConn.getSelectResultsType() != null) {
      exec.setSelectContentType(this.remoteConn.getSelectResultsType());
    }
    if (this.remoteConn.getModelResultsType() != null) {
      exec.setModelContentType(this.remoteConn.getModelResultsType());
    }

    // Return execution
    return exec;
  }
  public BedStats findAvailableBedsByClinic(Integer clinicId) {
    ClassLoader classLoader = getClass().getClassLoader();
    File file = new File(classLoader.getResource("sparqlQueries/BedsAvailabilityQuery").getFile());
    try {
      queryTemplate = FileUtils.readFileToString(file);
      List<String> params = new ArrayList<String>();
      params.add(clinicId.toString());
      String sparqlQuery = prepareQuery(queryTemplate, params);
      Query query = QueryFactory.create(sparqlQuery);
      QueryExecution qexec = QueryExecutionFactory.sparqlService(endpoint, query);
      System.out.println(sparqlQuery);
      ResultSet results = qexec.execSelect();
      if (results.hasNext()) {
        QuerySolution soln = results.nextSolution();

        Literal l = soln.getLiteral("bedsAvailable"); // Get a result variable - must be a literal
        BedStats bedStats = new BedStats();
        bedStats.setClinicId(clinicId);
        bedStats.setAvailabeBeds(l.getInt());
        return bedStats;
      } else {
        return null;
      }

    } catch (IOException e) {
      e.printStackTrace();
      return null;
    }
  }
Beispiel #5
0
  @Test
  public void testOpenQueryType() {
    eval = new MockSecurityEvaluator(true, true, true, true, true, true);

    setup();

    try {
      final String query =
          "prefix fn: <http://www.w3.org/2005/xpath-functions#>  "
              + " SELECT ?foo ?bar WHERE "
              + " { ?foo a <http://example.com/class> ; "
              + "?bar [] ."
              + "  } ";
      final QueryExecution qexec = QueryExecutionFactory.create(query, dataset);
      try {
        final ResultSet results = qexec.execSelect();
        int count = 0;
        for (; results.hasNext(); ) {
          count++;
          results.nextSolution();
        }
        Assert.assertEquals(8, count);
      } finally {
        qexec.close();
      }
    } finally {
      dataset.close();
    }
  }
  @Test
  public void testFullQueryWorks() {
    ReconnectingDatasetGraph toQuery =
        (ReconnectingDatasetGraph)
            ((Dataset) AssemblerUtils.build("basic.ttl", SDBConnect.TYPE)).asDatasetGraph();
    toQuery.getDatasetGraph().getStore().getTableFormatter().format();
    Dataset ds = DatasetImpl.wrap(toQuery);
    // Dataset ds = new DatasetImpl(toQuery);
    QueryExecution qe = QueryExecutionFactory.create("SELECT * { ?s ?p ?o }", ds);
    ResultSet r = qe.execSelect();
    assertTrue("Querying works", !r.hasNext());
    qe.close();

    qe = QueryExecutionFactory.create("SELECT * { graph ?g { ?s ?p ?o } }", ds);
    r = qe.execSelect();
    assertTrue("Querying with named graphs works", !r.hasNext());
    qe.close();
  }
  @Override
  public QueryExecution createQueryExecution(Query query) {
    // Plan plan = QueryExecutionFactory.createPlan(query, dataset, input, context);
    // plan.

    QueryExecution result = QueryExecutionFactory.create(query, model);
    // QueryExecution result = QueryExecutionWrapper.wrap(tmp);
    return result;
  }
  @Test
  public void testReconnectWorks() {
    ReconnectingDatasetGraph toQuery =
        (ReconnectingDatasetGraph)
            ((Dataset) AssemblerUtils.build("basic.ttl", SDBConnect.TYPE)).asDatasetGraph();
    toQuery.getDatasetGraph().getStore().getTableFormatter().format();
    Dataset ds = DatasetImpl.wrap(toQuery);
    // Dataset ds = new DatasetImpl(toQuery);
    QueryExecution qe = QueryExecutionFactory.create("ASK { ?s ?p ?o }", ds);
    assertTrue("Querying still works", !qe.execAsk());

    // Haha! Say goodbye!
    toQuery.getDatasetGraph().getStore().getConnection().close();

    qe = QueryExecutionFactory.create("ASK { ?s ?p ?o }", ds);
    assertTrue("Reconnected query still works", !qe.execAsk());

    qe = QueryExecutionFactory.create("ASK { ?s ?p ?o }", ds);
    assertTrue("Reconnected query works with test", !qe.execAsk());
  }
  public ResultSet executeQuery(String queryStr, String dialect) {
    //		System.out.println(queryStr);
    Query query = QueryFactory.create(queryStr);
    QueryExecution qe = QueryExecutionFactory.create(query, mapping);
    this.dialect = dialect;

    ResultSet rs = ConvertResults(qe.execSelect());
    qe.close();

    return rs;
  }
  @Test
  public void testSelectToWurcsSparql() throws SparqlException, UnsupportedEncodingException {
    GlycoSequenceToWurcsSelectSparql s = new GlycoSequenceToWurcsSelectSparql("glycoct");
    SparqlEntity se = new SparqlEntity();
    se.setValue(
        GlycoSequenceToWurcsSelectSparql.FromSequence,
        "RES\n1b:a-dgal-HEX-1:5\n2s:n-acetyl\n3b:b-dgal-HEX-1:5\n4b:b-dglc-HEX-1:5\n5s:n-acetyl\n6b:b-dgal-HEX-1:5\n7b:a-lgal-HEX-1:5|6:d\n8b:b-dglc-HEX-1:5\n9s:n-acetyl\n10b:b-dglc-HEX-1:5\n11s:n-acetyl\n12b:b-dgal-HEX-1:5\n13b:a-lgal-HEX-1:5|6:d\nLIN\n1:1d(2+1)2n\n2:1o(3+1)3d\n3:3o(3+1)4d\n4:4d(2+1)5n\n5:4o(4+1)6d\n6:6o(2+1)7d\n7:3o(6+1)8d\n8:8d(2+1)9n\n9:1o(6+1)10d\n10:10d(2+1)11n\n11:10o(4+1)12d\n12:12o(2+1)13d"
            .replaceAll("\n", "\\\\n"));
    s.setSparqlEntity(se);
    logger.debug(s.getSparql());
    Query query =
        QueryFactory.create(s.getSparql().replaceAll("null", "").replace("?Sequence", ""));
    //        QueryExecution qe =
    // QueryExecutionFactory.sparqlService("http://localhost:3030/glycobase/query",query);
    QueryExecution qe =
        QueryExecutionFactory.sparqlService("http://test.ts.glytoucan.org/sparql", query);
    ResultSet rs = qe.execSelect();

    List<SparqlEntity> results = new ArrayList<SparqlEntity>();

    while (rs.hasNext()) {
      QuerySolution row = rs.next();
      Iterator<String> columns = row.varNames();
      SparqlEntity se2 = new SparqlEntity();
      while (columns.hasNext()) {
        String column = columns.next();
        RDFNode cell = row.get(column);

        if (cell.isResource()) {
          Resource resource = cell.asResource();
          // do something maybe with the OntModel???
          if (resource.isLiteral()) se.setValue(column, resource.asLiteral().getString());
          else se.setValue(column, resource.toString());
        } else if (cell.isLiteral()) {
          se.setValue(column, cell.asLiteral().getString());
        } else if (cell.isAnon()) {
          se.setValue(column, "anon");
        } else {
          se.setValue(column, cell.toString());
        }
      }
      results.add(se);
    }

    for (SparqlEntity entity : results) {
      System.out.println("results: " + entity.getValue("PrimaryId"));
    }
  }
  /** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) */
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    /** Check for the input parameter and redirect. */
    PrintWriter writer = response.getWriter();
    response.setContentType("text/html");

    if (request.getParameter("input") != null && request.getParameter("input") != "") {
      String wikiDataQuery =
          "PREFIX p: <http://www.wikidata.org/prop/>\r\n"
              + "PREFIX wdt: <http://www.wikidata.org/prop/direct/>\r\n"
              + "PREFIX wd: <http://www.wikidata.org/entity/>\r\n"
              + "PREFIX wikibase: <http://wikiba.se/ontology#>\n"
              + "PREFIX bd: <http://www.bigdata.com/rdf#>\n"
              + "\r\n"
              + "SELECT ?musician ?musicianLabel ?genre ?genreLabel WHERE {\r\n"
              + "  {\r\n"
              + "      ?musician wdt:P106 wd:Q639669.\r\n"
              + "      ?musician wdt:P136 ?genre .\r\n"
              + "  }\r\n"
              + "  SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\r\n"
              + "}\r\n"
              + "ORDER BY DESC(?musician)";
      Query rawQuery = QueryFactory.create(wikiDataQuery);
      QueryExecution execute =
          QueryExecutionFactory.sparqlService("https://query.wikidata.org/sparql", rawQuery);
      ResultSet wikiDataResults = execute.execSelect();
      /*try
      {
      	insertRawDataToDB(wikiDataResults);
      }
      catch (ClassNotFoundException e)
      {
      	e.printStackTrace();
      }*/
      createResultTable(wikiDataResults, writer, request.getParameter("input"));
    } else if (request.getParameter("check") != null) {
      insertSelectedValuesToDB(request);
      response.sendRedirect("/TestWebProject/umut-dabager.jsp");
    } else if (request.getParameter("retrieve") != null) {
      writer.println(retrieveSavedResults());
    } else if (request.getParameter("clear") != null) {
      clearSavedResults();
      response.sendRedirect("/TestWebProject/umut-dabager.jsp");
    } else {
      response.sendRedirect("/TestWebProject/umut-dabager.jsp");
    }
  }
  public BedStats findHospitalAvailableBedsAllClinics(String hospital) {
    ApplicationContext appContext = new ClassPathXmlApplicationContext();
    org.springframework.core.io.Resource resource =
        appContext.getResource("classpath:sparqlQueries/BedsAvailabilityQuery");
    try {
      InputStream is = resource.getInputStream();
      BufferedReader br = new BufferedReader(new InputStreamReader(is));

      String line;
      queryTemplate = "";
      while ((line = br.readLine()) != null) {
        queryTemplate += line + "\n";
      }
      br.close();
    } catch (IOException e1) {
      e1.printStackTrace();
      return null;
    }

    List<String> params = new ArrayList<String>();
    params.add(hospital);
    params.add(hospital);
    String sparqlQuery = prepareQuery(queryTemplate, params);
    System.out.println(sparqlQuery);
    Query query = QueryFactory.create(sparqlQuery);
    QueryExecution qexec = QueryExecutionFactory.sparqlService(endpoint, query);
    ResultSet results = qexec.execSelect();
    if (results.hasNext()) {
      QuerySolution soln = results.next();

      Literal available = soln.getLiteral("available"); // Get a result variable - must be a literal
      Literal deployed = soln.getLiteral("deployed");
      Literal supplementary = soln.getLiteral("supplementary");
      // Literal lastDate = soln.getLiteral("maxDate");
      BedStats bedStats = new BedStats();
      bedStats.setHospitalName(params.get(0));
      bedStats.setAvailabeBeds(available.getInt());
      bedStats.setDeployedBeds(deployed.getInt());
      bedStats.setSupplementaryBeds(supplementary.getInt());
      // bedStats.setLastDate(lastDate.getShort());
      return bedStats;
    } else {
      return null;
    }
  }
Beispiel #13
0
  @Test
  public void testRestrictedQueryType() {
    eval =
        new MockSecurityEvaluator(true, true, true, true, true, true) {

          @Override
          public boolean evaluate(
              final Object principal,
              final Action action,
              final Node graphIRI,
              final Triple triple) {
            if (triple.getSubject().isURI()
                && triple.getSubject().getURI().equals("http://example.com/resource/1")) {
              return false;
            }
            return super.evaluate(principal, action, graphIRI, triple);
          }
        };

    setup();

    try {
      final String query =
          "prefix fn: <http://www.w3.org/2005/xpath-functions#>  "
              + " SELECT ?foo ?bar WHERE "
              + " { ?foo a <http://example.com/class> ; "
              + "?bar [] ."
              + "  } ";
      final QueryExecution qexec = QueryExecutionFactory.create(query, dataset);
      try {
        final ResultSet results = qexec.execSelect();
        int count = 0;
        for (; results.hasNext(); ) {
          count++;
          results.nextSolution();
        }
        Assert.assertEquals(4, count);
      } finally {
        qexec.close();
      }
    } finally {
      dataset.close();
    }
  }
  @Test
  public void testUnionWorks() {
    Dataset ds = (Dataset) AssemblerUtils.build("union.ttl", SDBConnect.TYPE);
    ReconnectingDatasetGraph toQuery = (ReconnectingDatasetGraph) ds.asDatasetGraph();
    toQuery.getDatasetGraph().getStore().getTableFormatter().format();
    UpdateRequest ur =
        UpdateFactory.create(
            "insert data {"
                + "graph <http://example.com/a> { <http://example.com/1> <http://example.com/prop> 1 }"
                + "graph <http://example.com/b> { <http://example.com/2> <http://example.com/prop> 2 }"
                + "}");
    UpdateProcessor u = UpdateExecutionFactory.create(ur, toQuery);
    u.execute();

    QueryExecution qe = QueryExecutionFactory.create("SELECT * { ?s ?p ?o }", ds);
    ResultSetRewindable r = ResultSetFactory.makeRewindable(qe.execSelect());

    assertEquals("We have a union!", 2, r.size());
  }
  @Test
  public void testSparql() {

    String queryStr = "select distinct ?Concept where {[] a ?Concept} LIMIT 10";
    Query query = QueryFactory.create(queryStr);

    // Remote execution.
    try (QueryExecution qexec =
        QueryExecutionFactory.sparqlService("http://dbpedia.org/sparql", query)) {
      // Set the DBpedia specific timeout.
      ((QueryEngineHTTP) qexec).addParam("timeout", "10000");

      // Execute.
      ResultSet rs = qexec.execSelect();
      ResultSetFormatter.out(System.out, rs, query);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public static List<String> listThingDescriptions(String query) {
    List<String> tds = new ArrayList<>();

    Dataset dataset = Repository.get().dataset;
    dataset.begin(ReadWrite.READ);

    try {
      String q = "SELECT DISTINCT ?g WHERE { GRAPH ?g { " + query + " }}";
      try (QueryExecution qexec = QueryExecutionFactory.create(q, dataset)) {
        ResultSet result = qexec.execSelect();
        while (result.hasNext()) {
          tds.add(result.next().get("g").asResource().getURI());
        }
      }
    } finally {
      dataset.end();
    }

    return tds;
  }
Beispiel #17
0
  public static void outputInfo(Model model, String var) {
    // compose the query
    String sparql =
        "BASE <http://example.org/inst/>"
            + "CONSTRUCT { <"
            + var
            + "> ?P ?O } "
            + "WHERE { <"
            + var
            + "> ?P ?O }";

    // carry out the query
    Query query = QueryFactory.create(sparql);
    QueryExecution qe = QueryExecutionFactory.create(query, model);
    Model results = qe.execConstruct();

    // print inferred triples
    System.out.println();
    System.out.println(var + ":");
    RDFDataMgr.write(System.out, results, RDFLanguages.NT);
  }
  public static ResultSet sparql(InstrumentosBean instrumentos, int acao) throws IOException {
    InputStream input =
        new FileInputStream(
            new File("C:/Users/nilso/workspace/InstrumentosIA/instrumentos_novo.rdf"));
    Model model = ModelFactory.createDefaultModel();
    model.read(input, null, "RDF/XML");
    input.close();
    String queryStr =
        " PREFIX rdf: <http://www.semanticweb.org/renan/ontologies/2015/7/untitled-ontology-2#>"
            + " SELECT ?rdf ?tipoInstrumento ?feitoDe ?numeroCordas ?temPes ?mediaPreco WHERE {"
            + " ?rdf rdf:feitoDe ?feitoDe ."
            + " ?rdf rdf:mediaPreco ?mediaPreco ."
            + " ?rdf rdf:numeroCordas ?numeroCordas ."
            + " ?rdf rdf:temPes ?temPes ."
            + " ?rdf rdf:tipoInstrumento ?tipoInstrumento.";

    if (Arrays.asList(1, 3, 5, 7, 9, 11, 13, 15).contains(acao))
      queryStr += " FILTER regex(?tipoInstrumento,'" + instrumentos.getTipoInstrumento() + "')";
    if (Arrays.asList(2, 3, 6, 7, 10, 11, 14, 15).contains(acao))
      queryStr += " FILTER regex(?feitoDe,'" + instrumentos.getFeitoDe() + "')";
    if (Arrays.asList(4, 5, 6, 7, 12, 13, 14, 15).contains(acao))
      queryStr +=
          " FILTER (?numeroCordas = " + String.valueOf(instrumentos.getNumeroCordas()) + ")";
    if (Arrays.asList(8, 9, 10, 11, 12, 13, 14, 15).contains(acao)) {
      queryStr +=
          " FILTER (?mediaPreco <= "
              + String.valueOf(instrumentos.getMaxPreco())
              + ")"
              + " FILTER (?mediaPreco >= "
              + String.valueOf(instrumentos.getMinPreco())
              + ")";
    }

    queryStr = queryStr + " }";

    Query query = QueryFactory.create(queryStr);
    consulta = QueryExecutionFactory.create(query, model);
    results = consulta.execSelect();
    return results;
  }
  @Test
  public void testDOQuery2() {

    String queryString =
        "prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
            + "prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n"
            + "prefix owl: <http://www.w3.org/2002/07/owl#>\n"
            + "\n"
            + "select *\n"
            + "from <http://purl.obolibrary.org/obo/merged/DOID>\n"
            + "\n"
            + "WHERE {\n"
            + "   <http://purl.obolibrary.org/obo/DOID_1485> <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o\n"
            + "}";

    Query query = QueryFactory.create(queryString);
    System.out.println("String: " + queryString);
    QueryExecution qExe =
        QueryExecutionFactory.sparqlService("http://sparql.hegroup.org/sparql/", query);
    ResultSet results = qExe.execSelect();
    ResultSetFormatter.out(System.out, results, query);
  }
  @Test
  public void testDO() {
    String doid = "1485";
    String queryString =
        "prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
            + "prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n"
            + "prefix owl: <http://www.w3.org/2002/07/owl#>\n"
            + "\n"
            + "select ?s ?p ?o \n"
            + "from <http://purl.obolibrary.org/obo/merged/DOID>\n"
            + "\n"
            + "WHERE {\n"
            + "   <http://purl.obolibrary.org/obo/DOID_"
            + doid
            + "> ?p ?o\n"
            + "}";

    Query query = QueryFactory.create(queryString);
    QueryExecution qExe =
        QueryExecutionFactory.sparqlService("http://sparql.hegroup.org/sparql/", query);
    ResultSet results = qExe.execSelect();
    ResultSetFormatter.out(System.out, results, query);

    assertNotNull(results);

    /*Model model = ModelFactory.createDefaultModel();
    Selector selector = new SimpleSelector(null, model.getProperty("<http://www.geneontology.org/formats/oboInOwl#hasDbXref>"), (RDFNode) null);  // you need to cast the last null as otherwise the method is ambigious
    */

    List<String> dbXref = new ArrayList<>();
    List<String> iao = new ArrayList<>();
    List<String> exactSynonym = new ArrayList<>();
    List<String> alternativeId = new ArrayList<>();
    String diseaseLabel;

    while (results.hasNext()) {
      QuerySolution querySolution = results.nextSolution();

      if (querySolution.get("p").toString().matches("rdfs:label ")) {
        diseaseLabel = querySolution.get("o").toString();
      }

      if (querySolution
          .get("p")
          .toString()
          .matches("http://www.geneontology.org/formats/oboInOwl#hasDbXref")) {
        System.out.println(
            querySolution.get("p").toString() + "   " + querySolution.get("o").toString());
        dbXref.add(querySolution.get("o").toString());
      }

      if (querySolution.get("p").toString().matches("http://purl.obolibrary.org/obo/IAO_0000115")) {
        System.out.println(
            querySolution.get("p").toString() + "   " + querySolution.get("o").toString());
        iao.add(querySolution.get("o").toString());
      }

      if (querySolution
          .get("p")
          .toString()
          .matches("http://www.geneontology.org/formats/oboInOwl#hasExactSynonym")) {
        System.out.println(
            querySolution.get("p").toString() + "   " + querySolution.get("o").toString());
        exactSynonym.add(querySolution.get("o").toString());
      }

      if (querySolution
          .get("p")
          .toString()
          .matches("http://www.geneontology.org/formats/oboInOwl#hasAlternativeId")) {
        System.out.println(
            querySolution.get("p").toString() + "   " + querySolution.get("o").toString());
        alternativeId.add(querySolution.get("o").toString());
      }
    }

    assertNotNull(dbXref);
    assertNotNull(iao);
  }
Beispiel #21
0
 /**
  * Create the {@link QueryExecution} for this operation.
  *
  * @param query
  * @param dataset
  * @return QueryExecution
  */
 protected QueryExecution createQueryExecution(Query query, Dataset dataset) {
   return QueryExecutionFactory.create(query, dataset);
 }
  @Override
  public EntityDefinition open(Assembler a, Resource root, Mode mode) {
    String prologue = "PREFIX : <" + NS + ">   PREFIX list: <http://jena.apache.org/ARQ/list#> ";
    Model model = root.getModel();

    String qs1 =
        StrUtils.strjoinNL(
            prologue,
            "SELECT * {",
            "  ?eMap  :entityField  ?entityField ;",
            "         :map ?map ;",
            "         :defaultField ?dftField .",
            "  OPTIONAL {",
            "    ?eMap :graphField ?graphField",
            "  }",
            "  OPTIONAL {",
            "    ?eMap :langField ?langField",
            "  }",
            "  OPTIONAL {",
            "    ?eMap :uidField ?uidField",
            "  }",
            "}");
    ParameterizedSparqlString pss = new ParameterizedSparqlString(qs1);
    pss.setIri("eMap", root.getURI());

    Query query1 = QueryFactory.create(pss.toString());
    QueryExecution qexec1 = QueryExecutionFactory.create(query1, model);
    ResultSet rs1 = qexec1.execSelect();
    List<QuerySolution> results = ResultSetFormatter.toList(rs1);
    if (results.size() == 0) {
      Log.warn(this, "Failed to find a valid EntityMap for : " + root);
      throw new TextIndexException("Failed to find a valid EntityMap for : " + root);
    }

    if (results.size() != 1) {
      Log.warn(this, "Multiple matches for EntityMap for : " + root);
      throw new TextIndexException("Multiple matches for EntityMap for : " + root);
    }

    QuerySolution qsol1 = results.get(0);
    String entityField = qsol1.getLiteral("entityField").getLexicalForm();
    String graphField =
        qsol1.contains("graphField") ? qsol1.getLiteral("graphField").getLexicalForm() : null;
    String langField =
        qsol1.contains("langField") ? qsol1.getLiteral("langField").getLexicalForm() : null;
    String defaultField =
        qsol1.contains("dftField") ? qsol1.getLiteral("dftField").getLexicalForm() : null;
    String uniqueIdField =
        qsol1.contains("uidField") ? qsol1.getLiteral("uidField").getLexicalForm() : null;

    Multimap<String, Node> mapDefs = HashMultimap.create();
    Map<String, Analyzer> analyzerDefs = new HashMap<>();

    Statement listStmt = root.getProperty(TextVocab.pMap);
    while (listStmt != null) {
      RDFNode n = listStmt.getObject();
      if (!n.isResource()) {
        throw new TextIndexException("Text list node is not a resource : " + n);
      }
      Resource listResource = n.asResource();
      if (listResource.equals(RDF.nil)) {
        break; // end of the list
      }

      Statement listEntryStmt = listResource.getProperty(RDF.first);
      if (listEntryStmt == null) {
        throw new TextIndexException("Text map list is not well formed.  No rdf:first property");
      }
      n = listEntryStmt.getObject();
      if (!n.isResource()) {
        throw new TextIndexException("Text map list entry is not a resource : " + n);
      }
      Resource listEntry = n.asResource();

      Statement fieldStatement = listEntry.getProperty(TextVocab.pField);
      if (fieldStatement == null) {
        throw new TextIndexException("Text map entry has no field property");
      }
      n = fieldStatement.getObject();
      if (!n.isLiteral()) {
        throw new TextIndexException("Text map entry field property has no literal value : " + n);
      }
      String field = n.asLiteral().getLexicalForm();

      Statement predicateStatement = listEntry.getProperty(TextVocab.pPredicate);
      if (predicateStatement == null) {
        throw new TextIndexException("Text map entry has no predicate property");
      }
      n = predicateStatement.getObject();
      if (!n.isURIResource()) {
        throw new TextIndexException(
            "Text map entry predicate property has non resource value : " + n);
      }
      mapDefs.put(field, n.asNode());

      Statement analyzerStatement = listEntry.getProperty(TextVocab.pAnalyzer);
      if (analyzerStatement != null) {
        n = analyzerStatement.getObject();
        if (!n.isResource()) {
          throw new TextIndexException("Text map entry analyzer property is not a resource : " + n);
        }
        Resource analyzerResource = n.asResource();
        Analyzer analyzer = (Analyzer) a.open(analyzerResource);
        analyzerDefs.put(field, analyzer);
      }

      // move on to the next element in the list
      listStmt = listResource.getProperty(RDF.rest);
    }

    // Primary field/predicate
    if (defaultField != null) {
      Collection<Node> c = mapDefs.get(defaultField);
      if (c.isEmpty())
        throw new TextIndexException("No definition of primary field '" + defaultField + "'");
    }

    EntityDefinition docDef = new EntityDefinition(entityField, defaultField);
    docDef.setGraphField(graphField);
    docDef.setLangField(langField);
    docDef.setUidField(uniqueIdField);
    for (String f : mapDefs.keys()) {
      for (Node p : mapDefs.get(f)) docDef.set(f, p);
    }
    for (String f : analyzerDefs.keySet()) {
      docDef.setAnalyzer(f, analyzerDefs.get(f));
    }
    return docDef;
  }
  @Test
  public void testGlycotoucanCTSearch() {

    List<Structure> structures = Ebean.find(Structure.class).findList();
    String ct = "";

    for (Structure structure : structures) {
      if (structure.id >= 7400) {

        if (structure.glycanst.startsWith("v--")) {
          structure.glycanst = structure.glycanst.replace("v--", "FreeEnd--");
        }

        if (structure.glycanst.startsWith("FreenEnd")) {
          structure.glycanst = structure.glycanst.replace("FreenEnd", "FreeEnd");
        }

        if (structure.glycanst.startsWith("FreeEnd?")) {
          structure.glycanst = structure.glycanst.replace("FreeEnd?", "FreeEnd--?");
        }

        if (structure.glycanst.startsWith("<Gly") || structure.glycanst.contains("0.0000u")) {
          continue;
        }

        System.out.println(structure.getGlycanst());

        BuilderWorkspace workspace = new BuilderWorkspace(new GlycanRendererAWT());
        workspace.setNotation("cfg"); // cfgbw | uoxf | uoxfcol | text

        GlycanRenderer renderer = workspace.getGlycanRenderer();

        org.eurocarbdb.application.glycanbuilder.Glycan glycan =
            org.eurocarbdb.application.glycanbuilder.Glycan.fromString(structure.glycanst);
        ct = glycan.toGlycoCTCondensed();

        // System.out.println(ct);
        //  }
        // }

        /*String ct = "RES\\n" +
                "1b:a-dgal-HEX-1:5\\n" +
                "2s:n-acetyl\\n" +
                "3b:b-dgal-HEX-1:5\\n" +
                "4b:a-lgal-HEX-1:5|6:d\\n" +
                "5b:a-dgal-HEX-1:5\\n" +
                "6s:n-acetyl\\n" +
                "7b:b-dglc-HEX-1:5\\n" +
                "8s:n-acetyl\\n" +
                "LIN\\n" +
                "1:1d(2+1)2n\\n" +
                "2:1o(3+1)3d\\n" +
                "3:3o(2+1)4d\\n" +
                "4:3o(3+1)5d\\n" +
                "5:5d(2+1)6n\\n" +
                "6:1o(6+1)7d\\n" +
                "7:7d(2+1)8n";

        ct = "RES\n" +
                "1b:b-dglc-HEX-1:5\n" +
                "2s:n-acetyl\n" +
                "3b:b-dglc-HEX-1:5\n" +
                "4s:n-acetyl\n" +
                "5b:b-dman-HEX-1:5\n" +
                "6b:a-dman-HEX-1:5\n" +
                "7b:a-dman-HEX-1:5\n" +
                "8b:a-lgal-HEX-1:5|6:d\n" +
                "LIN\n" +
                "1:1d(2+1)2n\n" +
                "2:1o(4+1)3d\n" +
                "3:3d(2+1)4n\n" +
                "4:3o(4+1)5d\n" +
                "5:5o(3+1)6d\n" +
                "6:5o(6+1)7d\n" +
                "7:1o(6+1)8d\n" +
                "UND\n" +
                "UND1:100.0:100.0\n" +
                "ParentIDs:1|3|5|6|7|8\n" +
                "SubtreeLinkageID1:x(-1+1)x\n" +
                "RES\n" +
                "9b:b-dglc-HEX-1:5\n" +
                "10s:n-acetyl\n" +
                "11b:a-lgal-HEX-1:5|6:d\n" +
                "12b:b-dgal-HEX-1:5\n" +
                "13b:a-dgro-dgal-NON-2:6|1:a|2:keto|3:d\n" +
                "14s:n-acetyl\n" +
                "LIN\n" +
                "8:9d(2+1)10n\n" +
                "9:9o(3+1)11d\n" +
                "10:9o(4+1)12d\n" +
                "11:12o(-1+2)13d\n" +
                "12:13d(5+1)14n\n" +
                "UND2:100.0:100.0\n" +
                "ParentIDs:1|3|5|6|7|8\n" +
                "SubtreeLinkageID1:x(-1+1)x\n" +
                "RES\n" +
                "15b:b-dglc-HEX-1:5\n" +
                "16s:n-acetyl\n" +
                "17b:a-lgal-HEX-1:5|6:d\n" +
                "18b:b-dgal-HEX-1:5\n" +
                "LIN\n" +
                "13:15d(2+1)16n\n" +
                "14:15o(3+1)17d\n" +
                "15:15o(4+1)18d\n" +
                "UND3:100.0:100.0\n" +
                "ParentIDs:1|3|5|6|7|8\n" +
                "SubtreeLinkageID1:x(-1+1)x\n" +
                "RES\n" +
                "19b:b-dglc-HEX-1:5\n" +
                "20s:n-acetyl\n" +
                "21b:b-dgal-HEX-1:5\n" +
                "LIN\n" +
                "16:19d(2+1)20n\n" +
                "17:19o(4+1)21d";
                */

        ct = ct.replaceAll("\n", "\\\\n").replaceAll("x\\(", "u\\(").replaceAll("\\)x", "\\)u");
        System.out.println("new ct: " + ct);

        String queryString =
            "PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n"
                + "PREFIX glycan: <http://purl.jp/bio/12/glyco/glycan#>\n"
                + "PREFIX wurcs: <http://www.glycoinfo.org/glyco/owl/wurcs#>\n"
                + "SELECT DISTINCT ?glycan ?c\n"
                + "# FROM <http://rdf.glycoinfo.org/wurcs/0.5.0>\n"
                + "# FROM <http://rdf.glycoinfo.org/wurcs/0.5.0/ms>\n"
                + "WHERE {\n"
                + "  ?glycan a \tglycan:glycosequence ;\n"
                + "\tglycan:in_carbohydrate_format  glycan:carbohydrate_format_glycoct ;\n"
                + "\tglycan:has_sequence\n"
                + "\t\t?c filter(contains(?c, \"RES\\n1b:b-dglc-HEX-1\")) .\n"
                +
                // "\t\t?c filter(contains(?c, \"" + ct + "\" )) .\n" +
                "\n"
                + "  }\n"
                + "  ORDER BY ?glycan\n"
                + "limit 10";

        System.out.println("String: " + queryString + "\t\tID: " + structure.id);

        Query query = QueryFactory.create(queryString);

        QueryExecution qExe =
            QueryExecutionFactory.sparqlService("http://test.ts.glytoucan.org/sparql", query);
        ResultSet results = qExe.execSelect();
        ResultSetFormatter.out(System.out, results, query);
      }
    }
  }
  @Test
  public void testWURCS() {

    String ct =
        "RES\n"
            + "1b:b-dglc-HEX-1:5\n"
            + "2s:n-acetyl\n"
            + "3b:b-dglc-HEX-1:5\n"
            + "4s:n-acetyl\n"
            + "5b:b-dman-HEX-1:5\n"
            + "6b:a-dman-HEX-1:5\n"
            + "7b:a-dman-HEX-1:5\n"
            + "8b:a-dman-HEX-1:5\n"
            + "9b:a-dman-HEX-1:5\n"
            + "10b:a-dman-HEX-1:5\n"
            + "LIN\n"
            + "1:1d(2+1)2n\n"
            + "2:1o(4+1)3d\n"
            + "3:3d(2+1)4n\n"
            + "4:3o(4+1)5d\n"
            + "5:5o(3+1)6d\n"
            + "6:6o(2+1)7d\n"
            + "7:5o(6+1)8d\n"
            + "8:8o(3+1)9d\n"
            + "9:8o(6+1)10d\n"
            + "UND\n"
            + "UND1:100.0:100.0\n"
            + "ParentIDs:7|9|10\n"
            + "SubtreeLinkageID1:o(2+1)d\n"
            + "RES\n"
            + "11b:a-dman-HEX-1:5";

    ct = ct.replaceAll("\n", "\\\\n");

    String queryString =
        "PREFIX glycan: <http://purl.jp/bio/12/glyco/glycan#>\n"
            + "PREFIX glytoucan:  <http://www.glytoucan.org/glyco/owl/glytoucan#>\n"
            + "PREFIX  xsd:  <http://www.w3.org/2001/XMLSchema#>\n"
            + "\n"
            + "SELECT DISTINCT ?Sequence\n"
            + "FROM <http://rdf.glytoucan.org>\n"
            + "FROM <http://rdf.glytoucan.org/sequence/wurcs>\n"
            + "\n"
            + "WHERE {\n"
            + "?SaccharideURI a glycan:saccharide .\n"
            + "?SaccharideURI glycan:has_glycosequence ?GlycanSequenceURI .\n"
            + "?GlycanSequenceURI glycan:has_sequence ?Sequence .\n"
            + "?GlycanSequenceURI glycan:in_carbohydrate_format glycan:carbohydrate_format_wurcs .\n"
            + "?SaccharideURI glycan:has_glycosequence ?FormatGlycoSequenceURI .\n"
            + "?FormatGlycoSequenceURI glycan:in_carbohydrate_format glycan:carbohydrate_format_glycoct .\n"
            + "?FormatGlycoSequenceURI glycan:has_sequence"
            + " \""
            + ct
            + "\""
            + "^^xsd:string ."
            + "}";

    System.out.println("String: " + queryString);

    Query query = QueryFactory.create(queryString);

    QueryExecution qExe =
        QueryExecutionFactory.sparqlService("http://test.ts.glytoucan.org/sparql", query);
    ResultSet results = qExe.execSelect();
    ResultSetFormatter.out(System.out, results, query);
  }
  @Test
  public void testKBtoWurcsSparql() throws SparqlException {

    List<Structure> structures = Ebean.find(Structure.class).findList();
    HashSet<String> resultList = new HashSet<>();

    String ct = "";

    for (Structure structure : structures) {
      if (structure.id >= 7400) {

        if (structure.glycanst.startsWith("v--")) {
          structure.glycanst = structure.glycanst.replace("v--", "FreeEnd--");
        }

        if (structure.glycanst.startsWith("FreenEnd")) {
          structure.glycanst = structure.glycanst.replace("FreenEnd", "FreeEnd");
        }

        if (structure.glycanst.startsWith("FreeEnd?")) {
          structure.glycanst = structure.glycanst.replace("FreeEnd?", "FreeEnd--?");
        }

        if (structure.glycanst.startsWith("<Gly") || structure.glycanst.contains("0.0000u")) {
          continue;
        }

        System.out.println(structure.getGlycanst());

        BuilderWorkspace workspace = new BuilderWorkspace(new GlycanRendererAWT());
        workspace.setNotation("cfg"); // cfgbw | uoxf | uoxfcol | text
        GlycanRenderer renderer = workspace.getGlycanRenderer();
        org.eurocarbdb.application.glycanbuilder.Glycan glycan =
            org.eurocarbdb.application.glycanbuilder.Glycan.fromString(structure.glycanst.trim());
        if (glycan != null) {
          ct = glycan.toGlycoCTCondensed();
          System.out.println("this was the ct: " + ct);
          GlycoSequenceToWurcsSelectSparql s = new GlycoSequenceToWurcsSelectSparql("glycoct");
          SparqlEntity se = new SparqlEntity();
          ct = StringUtils.chomp(ct);
          se.setValue(
              GlycoSequenceToWurcsSelectSparql.FromSequence,
              ct.replaceAll("\n", "\\\\n")
                  .replaceAll("x\\(", "u\\(")
                  .replaceAll("\\)x", "\\)u")
                  .trim());
          s.setSparqlEntity(se);
          logger.debug(s.getSparql());

          Query query =
              QueryFactory.create(s.getSparql().replaceAll("null", "").replace("?Sequence", ""));
          System.out.println(
              "Id "
                  + structure.id
                  + " Query: "
                  + s.getSparql().replaceAll("null", "").replace("?Sequence", ""));
          QueryExecution qe =
              QueryExecutionFactory.sparqlService("http://test.ts.glytoucan.org/sparql", query);
          ResultSet rs = qe.execSelect();

          List<SparqlEntity> results = new ArrayList<>();
          HashSet<String> resultsList = new HashSet<>();

          while (rs.hasNext()) {
            QuerySolution row = rs.next();
            Iterator<String> columns = row.varNames();
            SparqlEntity se2 = new SparqlEntity();
            while (columns.hasNext()) {
              String column = columns.next();
              RDFNode cell = row.get(column);

              if (cell.isResource()) {
                Resource resource = cell.asResource();
                // do something maybe with the OntModel???
                if (resource.isLiteral()) se.setValue(column, resource.asLiteral().getString());
                else se.setValue(column, resource.toString());
              } else if (cell.isLiteral()) {
                se.setValue(column, cell.asLiteral().getString());
              } else if (cell.isAnon()) {
                se.setValue(column, "anon");
              } else {
                se.setValue(column, cell.toString());
              }
            }
            results.add(se);
          }

          for (SparqlEntity entity : results) {
            // System.out.println("results: " + entity.getValue("PrimaryId"));
            resultList.add(structure.id + "\t" + entity.getValue("PrimaryId").toString());
          }
        }
      }
    }
    PrintWriter writer = null;
    try {
      writer =
          new PrintWriter(
              new OutputStreamWriter(new FileOutputStream("/tmp/HashSet.txt"), "UTF-8"));
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
    for (String c : resultList) {
      System.out.println(c);
      writer.println(c);
    }
  }
  @Test
  public void testKBtoWurcsSparqlTranslation() throws SparqlException {

    List<Translation> translations = Ebean.find(Translation.class).findList();
    HashSet<String> resultList = new HashSet<>();

    String ct = "";

    for (Translation translation : translations) {
      System.out.println("id check " + translation.id + " ct " + translation.ct);
      if (translation.ct == null) continue;

      if (translation.structure.id > 0) {

        ct = translation.ct;

        GlycoSequenceToWurcsSelectSparql s = new GlycoSequenceToWurcsSelectSparql("glycoct");
        SparqlEntity se = new SparqlEntity();
        ct = StringUtils.chomp(ct);
        System.out.println("ct on top: " + ct);
        if (ct != null) {
          se.setValue(
              GlycoSequenceToWurcsSelectSparql.FromSequence,
              ct.replaceAll("\n", "\\\\n")
                  .replaceAll("x\\(", "u\\(")
                  .replaceAll("\\)x", "\\)u")
                  .trim());
          s.setSparqlEntity(se);
          logger.debug(s.getSparql());

          Query query =
              QueryFactory.create(s.getSparql().replaceAll("null", "").replace("?Sequence", ""));
          System.out.println(
              "Id "
                  + translation.structure.id
                  + " Query: "
                  + s.getSparql().replaceAll("null", "").replace("?Sequence", ""));
          QueryExecution qe =
              QueryExecutionFactory.sparqlService("http://test.ts.glytoucan.org/sparql", query);
          ResultSet rs = qe.execSelect();

          List<SparqlEntity> results = new ArrayList<>();
          HashSet<String> resultsList = new HashSet<>();

          while (rs.hasNext()) {
            QuerySolution row = rs.next();
            Iterator<String> columns = row.varNames();
            SparqlEntity se2 = new SparqlEntity();
            while (columns.hasNext()) {
              String column = columns.next();
              RDFNode cell = row.get(column);

              if (cell.isResource()) {
                Resource resource = cell.asResource();
                // do something maybe with the OntModel???
                if (resource.isLiteral()) se.setValue(column, resource.asLiteral().getString());
                else se.setValue(column, resource.toString());
              } else if (cell.isLiteral()) {
                se.setValue(column, cell.asLiteral().getString());
              } else if (cell.isAnon()) {
                se.setValue(column, "anon");
              } else {
                se.setValue(column, cell.toString());
              }
            }
            results.add(se);
          }

          for (SparqlEntity entity : results) {
            // System.out.println("results: " + entity.getValue("PrimaryId"));
            resultList.add(
                translation.structure.id + "\t" + entity.getValue("PrimaryId").toString());
          }
        }
      }
    }

    for (String c : resultList) {
      System.out.println(c);
    }
  }