private boolean isObsolete(Resource ctx) throws SailException {
   CloseableIteration<? extends Statement, SailException> stmts;
   stmts = super.getStatements(null, null, null, true, ctx);
   try {
     while (stmts.hasNext()) {
       Statement st = stmts.next();
       URI pred = st.getPredicate();
       Value obj = st.getObject();
       String ns = pred.getNamespace();
       if (Audit.NAMESPACE.equals(ns) || PROV.equals(ns) || AUDIT_2012.equals(ns)) continue;
       if (RDF.SUBJECT.equals(pred) || RDF.PREDICATE.equals(pred) || RDF.OBJECT.equals(pred))
         continue;
       if (RDF.TYPE.equals(pred) && obj instanceof URI) {
         ns = ((URI) obj).getNamespace();
         if (Audit.NAMESPACE.equals(ns)
             || PROV.equals(ns)
             || AUDIT_2012.equals(ns)
             || RDF.NAMESPACE.equals(ns)) continue;
       }
       return false;
     }
   } finally {
     stmts.close();
   }
   return true;
 }
  /**
   * find properties with no domain or range defined and also add some generic elements like label
   * or type
   *
   * @return
   */
  List<OntologyElement> findHangingElements() throws Exception {
    List<OntologyElement> elements = new ArrayList<OntologyElement>();
    Set<String> properties = new HashSet<String>();
    properties.add(RDFS.LABEL.toString());
    properties.add(RDF.TYPE.toString());
    String table = suggestionsHelper.getDatatypePropertiesNoDomain();
    properties.addAll(StringUtil.fromStringToSet(table));

    String thingUri = "http://www.w3.org/2002/07/owl#Thing";
    properties.addAll(
        luceneAnnotator.getDefinedPropertiesWhereClassIsADomain(thingUri, forceSuperClasses));
    properties.addAll(
        luceneAnnotator.getDefinedPropertiesWhereClassIsARange(thingUri, forceSuperClasses));
    elements.addAll(returnPropertyElements(properties));

    logger.info("Adding:" + properties.size() + " hanging properties");

    Set<String> classes = new HashSet<String>();
    classes.add(thingUri);
    elements.addAll(returnClassElements(classes));
    return elements;
  }
 /**
  * Asynchronously explains why {@code instance} is an instance of {@code cl}
  *
  * @param instance The instance
  * @param cl The class
  * @param callback The {@link Callback} to execute after the explanation is done
  */
 public void instance(Resource instance, Resource cl, Callback<Graph> callback) {
   String query = selectQuery(instance.toString(), RDF.TYPE.stringValue(), cl.stringValue());
   query(query, callback);
 }
 /**
  * Explains why {@code instance} is an instance of {@code cl}
  *
  * @param instance The instance
  * @param cl The class
  * @return The explanation {@link org.openrdf.model.Graph Graph}
  * @throws PelletClientException If there is an error or the {@code instance} is not an instance
  *     of {@code cl}
  */
 public Graph instance(Resource instance, Resource cl) throws PelletClientException {
   String query = selectQuery(instance.toString(), RDF.TYPE.stringValue(), cl.stringValue());
   return query(query);
 }
Exemple #5
0
public class SesameDataSet {

  // Log
  private static Log log = LogFactory.getLog(SesameDataSet.class);

  private Repository currentRepository = null;

  // useful -local- constants
  static RDFFormat NTRIPLES = RDFFormat.NTRIPLES;
  static RDFFormat N3 = RDFFormat.N3;
  static RDFFormat RDFXML = RDFFormat.RDFXML;
  static String RDFTYPE = RDF.TYPE.toString();

  /** In memory Sesame repository without inferencing */
  public SesameDataSet() {
    this(false);
  }

  /**
   * In memory Sesame repository with optional inferencing
   *
   * @param inferencing
   */
  public SesameDataSet(boolean inferencing) {
    try {
      if (inferencing) {
        currentRepository =
            new SailRepository(new ForwardChainingRDFSInferencer(new MemoryStore()));
      } else {
        currentRepository = new SailRepository(new MemoryStore());
      }
      currentRepository.initialize();
    } catch (RepositoryException e) {
      e.printStackTrace();
    }
  }

  public SesameDataSet(String pathToDir, boolean inferencing) {
    File f = new File(pathToDir);
    try {
      if (inferencing) {
        currentRepository =
            new SailRepository(new ForwardChainingRDFSInferencer(new NativeStore(f)));
      } else {
        currentRepository = new SailRepository(new NativeStore(f));
      }
      currentRepository.initialize();
    } catch (RepositoryException e) {
      e.printStackTrace();
    }
  }

  public SesameDataSet(String sesameServer, String repositoryID) {
    currentRepository = new HTTPRepository(sesameServer, repositoryID);
    try {
      currentRepository.initialize();
    } catch (RepositoryException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

  /**
   * Load data in specified graph (use default graph if contexts is null)
   *
   * @param filePath
   * @param format
   * @param contexts
   */
  public void loadDataFromFile(String filePath, RDFFormat format, Resource... contexts) {
    RepositoryConnection con;
    try {
      con = currentRepository.getConnection();
      try {
        // upload a file
        File f = new File(filePath);
        con.add(f, null, format, contexts);

      } catch (RDFParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (RepositoryException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } finally {
        try {
          con.close();
        } catch (RepositoryException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
    } catch (RepositoryException e1) {
      // TODO Auto-generated catch block
      e1.printStackTrace();
    }
  }

  public void loadDataFromURL(String stringURL) {
    RepositoryConnection con;
    try {
      con = currentRepository.getConnection();
      try {
        // upload a URL
        URL url = new URL(stringURL);
        con.add(url, null, RDFFormat.RDFXML);

      } catch (RDFParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (RepositoryException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } finally {
        try {
          con.close();
        } catch (RepositoryException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
    } catch (RepositoryException e1) {
      // TODO Auto-generated catch block
      e1.printStackTrace();
    }
  }

  /**
   * Literal factory
   *
   * @param s the literal value
   * @param typeuri uri representing the type (generally xsd)
   * @return
   */
  public org.openrdf.model.Literal Literal(String s, URI typeuri) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        ValueFactory vf = con.getValueFactory();
        if (typeuri == null) {
          return vf.createLiteral(s);
        } else {
          return vf.createLiteral(s, typeuri);
        }
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * Untyped Literal factory
   *
   * @param s the literal
   * @return
   */
  public org.openrdf.model.Literal Literal(String s) {
    return Literal(s, null);
  }

  /**
   * URIref factory
   *
   * @param uri
   * @return
   */
  public URI URIref(String uri) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        ValueFactory vf = con.getValueFactory();
        return vf.createURI(uri);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * BNode factory
   *
   * @return
   */
  public BNode bnode() {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        ValueFactory vf = con.getValueFactory();
        return vf.createBNode();
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * Insert Triple/Statement into graph
   *
   * @param s subject uriref
   * @param p predicate uriref
   * @param o value object (URIref or Literal)
   * @param contexts varArgs context objects (use default graph if null)
   */
  public void add(Resource s, URI p, Value o, Resource... contexts) {
    if (log.isDebugEnabled())
      log.debug(
          "[SesameDataSet:add] Add triple ("
              + s.stringValue()
              + ", "
              + p.stringValue()
              + ", "
              + o.stringValue()
              + ").");
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        ValueFactory myFactory = con.getValueFactory();
        Statement st = myFactory.createStatement((Resource) s, p, (Value) o);
        con.add(st, contexts);
        con.commit();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        con.close();
      }
    } catch (Exception e) {
      // handle exception
    }
  }

  public void remove(Resource s, URI p, Value o, Resource... context) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        ValueFactory myFactory = con.getValueFactory();
        Statement st = myFactory.createStatement((Resource) s, p, (Value) o);
        con.remove(st, context);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      // handle exception
    }
  }

  /**
   * Import RDF data from a string
   *
   * @param rdfstring string with RDF data
   * @param format RDF format of the string (used to select parser)
   */
  public void addString(String rdfstring, RDFFormat format) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        StringReader sr = new StringReader(rdfstring);
        con.add(sr, "", format);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Import RDF data from a file
   *
   * @param location of file (/path/file) with RDF data
   * @param format RDF format of the string (used to select parser)
   */
  public void addFile(String filepath, RDFFormat format) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        con.add(new File(filepath), "", format);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Import data from URI source Request is made with proper HTTP ACCEPT header and will follow
   * redirects for proper LOD source negotiation
   *
   * @param urlstring absolute URI of the data source
   * @param format RDF format to request/parse from data source
   */
  public void addURI(String urlstring, RDFFormat format) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        URL url = new URL(urlstring);
        URLConnection uricon = (URLConnection) url.openConnection();
        uricon.addRequestProperty("accept", format.getDefaultMIMEType());
        InputStream instream = uricon.getInputStream();
        con.add(instream, urlstring, format);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Dump RDF graph
   *
   * @param out output stream for the serialization
   * @param outform the RDF serialization format for the dump
   * @return
   */
  public void dumpRDF(OutputStream out, RDFFormat outform) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        RDFWriter w = Rio.createWriter(outform, out);
        con.export(w);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * dump RDF graph
   *
   * @param filePath destination file for the serialization
   * @param outform the RDF serialization format for the dump
   * @return
   */
  public void dumpRDF(String filePath, RDFFormat outform) {
    OutputStream output;
    try {
      output = new FileOutputStream(filePath);

      dumpRDF(output, outform);
      try {
        output.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }

  public String printRDF(RDFFormat outform) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        RDFWriter w = Rio.createWriter(outform, out);

        con.export(w);
        String result = new String(out.toByteArray(), "UTF-8");
        return result;
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * Convenience URI import for RDF/XML sources
   *
   * @param urlstring absolute URI of the data source
   */
  public void addURI(String urlstring) {
    addURI(urlstring, RDFFormat.RDFXML);
  }

  /**
   * Tuple pattern query - find all statements with the pattern, where null is a wildcard
   *
   * @param s subject (null for wildcard)
   * @param p predicate (null for wildcard)
   * @param o object (null for wildcard)
   * @param contexts varArgs contexts (use default graph if null)
   * @return serialized graph of results
   */
  public List<Statement> tuplePattern(Resource s, URI p, Value o, Resource... contexts) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        RepositoryResult<Statement> repres = con.getStatements(s, p, o, true, contexts);
        ArrayList<Statement> reslist = new ArrayList<Statement>();
        while (repres.hasNext()) {
          reslist.add(repres.next());
        }
        return reslist;
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * Execute a CONSTRUCT/DESCRIBE SPARQL query against the graphs
   *
   * @param qs CONSTRUCT or DESCRIBE SPARQL query
   * @param format the serialization format for the returned graph
   * @return serialized graph of results
   */
  public String runSPARQL(String qs, RDFFormat format) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        GraphQuery query = con.prepareGraphQuery(org.openrdf.query.QueryLanguage.SPARQL, qs);
        StringWriter stringout = new StringWriter();
        RDFWriter w = Rio.createWriter(format, stringout);
        query.evaluate(w);
        return stringout.toString();
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * Execute a SELECT SPARQL query against the graphs
   *
   * @param qs SELECT SPARQL query
   * @return list of solutions, each containing a hashmap of bindings
   */
  public List<HashMap<String, Value>> runSPARQL(String qs) {
    try {
      RepositoryConnection con = currentRepository.getConnection();
      try {
        TupleQuery query = con.prepareTupleQuery(org.openrdf.query.QueryLanguage.SPARQL, qs);
        TupleQueryResult qres = query.evaluate();
        ArrayList<HashMap<String, Value>> reslist = new ArrayList<HashMap<String, Value>>();
        while (qres.hasNext()) {
          BindingSet b = qres.next();

          Set<String> names = b.getBindingNames();
          HashMap<String, Value> hm = new HashMap<String, Value>();
          for (String n : names) {
            hm.put(n, b.getValue(n));
          }
          reslist.add(hm);
        }
        return reslist;
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * Execute CONSTRUCT/DESCRIBE SPARQL queries against the graph from a SPARQL request file. This
   * file contains only one request. // TODO : up this limit
   *
   * @param pathToFile path to SPARQL request file
   * @return list of solutions, each containing a hashmap of bindings
   */
  public String runSPARQLFromFile(String pathToSPARQLFile, RDFFormat format) {
    // Read SPARQL request
    String s = null;
    StringBuffer sb = new StringBuffer();
    try {
      FileReader fr = new FileReader(new File(pathToSPARQLFile));
      // be sure to not have line starting with "--" or "/*" or any other
      // non aplhabetical character
      BufferedReader br = new BufferedReader(fr);
      while ((s = br.readLine()) != null) {
        sb.append(s);
      }
      br.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
    if (log.isDebugEnabled())
      log.debug("[Graph:runSPARQLFromFile] SPARQL query : " + sb.toString());
    return runSPARQL(sb.toString(), format);
  }

  /**
   * Execute SELECT SPARQL queries against the graph from a SPARQL request file. This file contains
   * only one request. // TODO : up this limit
   *
   * @param pathToFile path to SPARQL request file
   * @return list of solutions, each containing a hashmap of bindings
   */
  public List<HashMap<String, Value>> runSPARQLFromFile(String pathToSPARQLFile) {
    // Read SPARQL request
    String s = null;
    StringBuffer sb = new StringBuffer();
    try {
      FileReader fr = new FileReader(new File(pathToSPARQLFile));
      // be sure to not have line starting with "--" or "/*" or any other
      // non aplhabetical character
      BufferedReader br = new BufferedReader(fr);
      while ((s = br.readLine()) != null) {
        sb.append(s);
      }
      br.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
    if (log.isDebugEnabled())
      log.debug("[Graph:runSPARQLFromFile] SPARQL query : " + sb.toString());
    return runSPARQL(sb.toString());
  }

  /**
   * Close current repository.
   *
   * @throws RepositoryException
   */
  public void closeRepository() throws RepositoryException {
    currentRepository.shutDown();
  }

  /** Return the number of triples in the repository. */
  public int getSize() {
    return tuplePattern(null, null, null).size();
  }

  public String toString() {
    String result = "{[SimpleGraph:toString] triples = ";
    List<Statement> triples = tuplePattern(null, null, null);
    for (Object o : triples) result += o + System.getProperty("line.separator");
    result += "}";
    return result;
  }
}
public class SimpleSesameGraph {

  Repository therepository = null;

  // useful -local- constants
  static RDFFormat NTRIPLES = RDFFormat.NTRIPLES;
  static RDFFormat N3 = RDFFormat.N3;
  static RDFFormat RDFXML = RDFFormat.RDFXML;
  static String RDFTYPE = RDF.TYPE.toString();

  /** In memory Sesame repository without type inferencing */
  public SimpleSesameGraph() {
    this(false);
  }

  /**
   * In memory Sesame Repository with optional inferencing
   *
   * @param inferencing determines whether we load the inferencer or not
   */
  public SimpleSesameGraph(boolean inferencing) {
    try {
      if (inferencing) {
        therepository = new SailRepository(new ForwardChainingRDFSInferencer(new MemoryStore()));

      } else {
        therepository = new SailRepository(new MemoryStore());
      }
      therepository.initialize();
    } catch (RepositoryException e) {
      e.printStackTrace();
    }
  }

  /**
   * Literal factory
   *
   * @param s the literal value
   * @param typeuri uri representing the type (generally xsd)
   * @return Literal type
   */
  public org.openrdf.model.Literal Literal(String s, URI typeuri) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        ValueFactory vf = con.getValueFactory();
        if (typeuri == null) {
          return vf.createLiteral(s);
        } else {
          return vf.createLiteral(s, typeuri);
        }
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * Untyped Literal factory
   *
   * @param s the literal
   * @return Literal value
   */
  public org.openrdf.model.Literal Literal(String s) {
    return Literal(s, null);
  }

  /**
   * UR Iref factory
   *
   * @param uri to build
   * @return URI resource
   */
  public URI URIref(String uri) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        ValueFactory vf = con.getValueFactory();
        return vf.createURI(uri);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * BNode factory
   *
   * @return BNode a blank node
   */
  public BNode bnode() {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        ValueFactory vf = con.getValueFactory();
        return vf.createBNode();
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * dump RDF graph
   *
   * @param out output stream for the serialization
   * @param outform the RDF serialization format for the dump
   */
  public void dumpRDF(OutputStream out, RDFFormat outform) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        RDFWriter w = Rio.createWriter(outform, out);
        con.export(w);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Convenience URI import for RDF/XML sources
   *
   * @param urlstring absolute URI of the data source
   */
  public void addURI(String urlstring) {
    addURI(urlstring, RDFFormat.RDFXML);
  }

  /**
   * Import data from URI source Request is made with proper HTTP ACCEPT header and will follow
   * redirects for proper LOD source negotiation
   *
   * @param urlstring absolute URI of the data source
   * @param format RDF format to request/parse from data source
   */
  public void addURI(String urlstring, RDFFormat format) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        URL url = new URL(urlstring);
        URLConnection uricon = url.openConnection();
        uricon.addRequestProperty("accept", format.getDefaultMIMEType());
        InputStream instream = uricon.getInputStream();
        con.add(instream, urlstring, format);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Import RDF data from a string
   *
   * @param rdfstring string with RDF data
   * @param format RDF format of the string (used to select parser)
   */
  public void addString(String rdfstring, RDFFormat format) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        StringReader sr = new StringReader(rdfstring);
        con.add(sr, "", format);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Import RDF data from a file
   *
   * @param filepath of file (/path/file) with RDF data
   * @param format RDF format of the string (used to select parser)
   */
  public void addFile(String filepath, RDFFormat format) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        con.add(new File(filepath), "", format);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * Insert Triple/Statement into graph
   *
   * @param s subject uriref
   * @param p predicate uriref
   * @param o value object (URIref or Literal)
   */
  public void add(URI s, URI p, Value o) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        ValueFactory myFactory = con.getValueFactory();
        Statement st = myFactory.createStatement(s, p, o);
        con.add(st);
      } finally {
        con.close();
      }
    } catch (Exception e) {
      // handle exception
    }
  }

  /**
   * Tuple pattern query - find all statements with the pattern, where null is a wild card
   *
   * @param s subject (null for wildcard)
   * @param p predicate (null for wildcard)
   * @param o object (null for wildcard)
   * @return serialized graph of results
   */
  public List<Statement> tuplePattern(URI s, URI p, Value o) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        RepositoryResult<Statement> repres = con.getStatements(s, p, o, true);
        ArrayList<Statement> reslist = new ArrayList<Statement>();
        while (repres.hasNext()) {
          reslist.add(repres.next());
        }
        return reslist;
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * Execute a CONSTRUCT/DESCRIBE SPARQL query against the graph
   *
   * @param qs CONSTRUCT or DESCRIBE SPARQL query
   * @param format the serialization format for the returned graph
   * @return serialized graph of results
   */
  public String runSPARQL(String qs, RDFFormat format) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        GraphQuery query = con.prepareGraphQuery(org.openrdf.query.QueryLanguage.SPARQL, qs);
        StringWriter stringout = new StringWriter();
        RDFWriter w = Rio.createWriter(format, stringout);
        query.evaluate(w);
        return stringout.toString();
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  /**
   * Execute a SELECT SPARQL query against the graph
   *
   * @param qs SELECT SPARQL query
   * @return list of solutions, each containing a hashmap of bindings
   */
  public List<HashMap<Object, Value>> runSPARQL(String qs) {
    try {
      RepositoryConnection con = therepository.getConnection();
      try {
        TupleQuery query = con.prepareTupleQuery(org.openrdf.query.QueryLanguage.SPARQL, qs);
        TupleQueryResult qres = query.evaluate();
        ArrayList<HashMap<Object, Value>> reslist = new ArrayList<HashMap<Object, Value>>();
        while (qres.hasNext()) {
          BindingSet b = qres.next();
          Set<String> names = b.getBindingNames();
          HashMap<Object, Value> hm = new HashMap<Object, Value>();
          for (Object n : names) {
            hm.put(n, b.getValue((String) n));
          }
          reslist.add(hm);
        }
        return reslist;
      } finally {
        con.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

  public static void main(String[] args) {

    // create a graph with type inferencing
    SimpleSesameGraph g = new SimpleSesameGraph(true);

    //        //load the film schema and the example data
    //        g.addFile("../roadstead_ontologies/film-ontology.owl", SimpleSesameGraph.RDFXML);

    // try loading the geopolitical ontology
    g.addURI("http://aims.fao.org/aos/geopolitical.owl");

    //        List<HashMap<Object, Value>> solutions = g.runSPARQL("SELECT ?who WHERE  { " +
    //                "?who <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
    // <http://roadstead.org/film#Person> ." +
    //                "}");

    /*
    Here we are looking for the names of all the things with a name
     */
    List<HashMap<Object, Value>> solutions =
        g.runSPARQL(
            "SELECT ?name WHERE  { "
                + "?what <http://aims.fao.org/aos/geopolitical.owl#territory> ?name ."
                + "?what <http://aims.fao.org/aos/geopolitical.owl#nameListEN> ?name ."
                + "}");
    for (HashMap<Object, Value> object : solutions) {
      for (Value value : object.values()) {
        System.out.println("country: " + value.stringValue());
      }
    }
  }
}