BC:xtalas:SesameAPI

Z FI WIKI
Přejít na: navigace, hledání

Sesame API

Sail API

Storage and inference API - vnitřní, abstrahuje zbytek systému od způsobu uložení (databáze, paměť) a přidává podporu pro odvozování.


Access API

Dělí se na Graph API(přidávání/odebírání tvrzení) a Repository API(dotazování, ukládání RDF).

Provádí komunikaci mezi sesame moduly a aplikací s ním komunikující.


Repository API

http://openrdf.org/doc/sesame/users/ch07.html#d0e2134

Rozhraní jsou v balíku: org.openrdf.sesame.repository. V podbalíčcích jsou implementace těchto rozhraní pro lokální i vzdálené repositories.

Pro práci s repozitářem je nejprve třeba vytvořit objekt SesameRepository, který ho bude reprezentovat.

Lokální repozitáře:

Používané přímo v aplikacích pokud je potřeba, vytvoření odvozovacího repozitáře v paměti:

 LocalService service = Sesame.getService();
 boolean inferencing = true;
 LocalRepository myRepository = service.createRepository("myRep", inferencing);

Objekt RepositoryConfig změní nastavení repozitáře, např.aby používal soubor pro tvalé uložení

RepositoryConfig repConfig = new RepositoryConfig("myCustomRep");
SailConfig syncSail = new SailConfig("org.openrdf.sesame.sailimpl.sync.SyncRdfSchemaRepository");
SailConfig memSail = new org.openrdf.sesame.sailimpl.memory.RdfSchemaRepositoryConfig(
                                                "C:\\tmp\\myCustomRep.rdf", RDFFormat.RDFXML);
repConfig.addSail(syncSail);
repConfig.addSail(memSail);
repConfig.setWorldReadable(true);
repConfig.setWorldWriteable(true);


Je hotová specifikace a zbývá vytvořit repozitář:

LocalRepository myCustomRepository = service.createRepository(repConfig);


Vzdálené repozitáře:

java.net.URL sesameServerURL = new java.net.URL("http://HOSTNAME/SESAME_DIR/");
SesameService service = Sesame.getService(sesameServerURL);
service.login("USERNAME", "PASSWORD");

Komunikace se serverem

The Sesame server is represented by the class org.openrdf.sesame.server.SesameServer. Among other things, this class allows us to retrieve the LocalService that is used by the server by calling the getLocalService() method: LocalService service = SesameServer.getLocalService();

Using this object we can get to the available repositories in an identical fashion as in the local repository scenario.


Dotazování repozitáře

String query = "SELECT * FROM {x} p {y}";
QueryResultsTable resultsTable = myRepository.performTableQuery(QueryLanguage.SERQL, query);
int rowCount = resultsTable.getRowCount();
int columnCount = resultsTable.getColumnCount();
for (int row = 0; row < rowCount; row++) {
   for (int column = 0; column < columnCount; column++) {
       Value value = resultsTable.getValue(row, column);
       if (value != null) {
           System.out.print(value.toString());
       }
       else {
           System.out.print("null");
       }
       System.out.print("\t");
   }
   System.out.println();
}

Přidání záznamů

Z lokálního souboru, z webu nebo pomocí Stringu. Ale přes API repository nejdou přidat jednotlivé RDF záznamy, na to je potřeba jít přes Graph API. Přidává se metodou addData(), první parametr je zdroj dat(String, java.net.URL, java.io.File, java.io.InpuStream). Listener zachytává hlášení a chyby.

java.net.URL myRDFData = new java.net.URL("http://www.foo.com/bar/myRdfFile.rdf");
String baseURI = "http://my.base.uri#";
boolean verifyData = true;
AdminListener myListener = new StdOutAdminListener();
myRepository.addData(myRDFData, baseURI, RDFFormat.RDFXML, verifyData, myListener);


Graph API

Balík org.openrdf.model.Graph. Graf se může měnit jednotlivými příkazy nebo spouštěním SeRQL-construct dotazů.


Vytvoření prázdného grafu:

Graph myGraph = new org.openrdf.model.impl.GraphImpl();


Přidání záznamů:

ValueFactory myFactory = myGraph.getValueFactory();
String namespace = "http://www.foo.com/bar#";

URI mySubject = myFactory.createURI(namespace, "actor1");
URI myPredicate = myFactory.createURI(namespace, "hasName");
Literal myObject = myFactory.createLiteral("Tom Hanks");

myGraph.add(mySubject, myPredicate, myObject);


Přidávání properties k URI:

URI actorClass = myFactory.createURI(namespace, "Actor");
URI rdfType = myFactory.createURI(org.openrdf.vocabulary.RDF.TYPE);
mySubject.addProperty(rdfType, actorClass);

Ekvivalentně:

URI actorClass = myFactory.createURI(namespace, "Actor");
URI rdfType = myFactory.createURI(org.openrdf.vocabulary.RDF.TYPE);
myGraph.add(mySubject, rdfType, actorClass);

A přidání/odebrání grafu do/z repozitáře:

myRepository.addGraph(myGraph);
myRepository.removeGraph(myGraph);

Vytvoření grafu z (lokálního) repozitáře:

Graph myGraph = myLocalRepository.getGraph();


Tvoření grafu pomocí dotazu Pro vytvoření lokální kopie nebo subsetu RDF grafu i ze vzdálené repository. Používá se SeRQL-construct jazyk.

String query = "CONSTRUCT * FROM {SubClass} rdfs:subClassOf {SuperClass}";
Graph classHierarchy = myRepository.performGraphQuery(QueryLanguage.SERQL, query);

Vytvořený graf bude vzhledem k repozitáři nezávislý.


Update tvrzení v repo pomocí graph API


myRepository.addGraph(QueryLanguage.SERQL,

   "CONSTRUCT {X} <http://www.foo.com/bar#NumberOfWheels> {\"4\"} " +
   "FROM {X} <http://www.foo.com/bar#NumberOfWheels> {\"3\"}");

myRepository.removeGraph(QueryLanguage.SERQL,

   "CONSTRUCT * " + 
   "FROM {X} <http://www.foo.com/bar#NumberOfWheels> {\"3\"}";


Moje zdrojáky

package cz.muni.fi.xtalas1.sesameapi; 

import java.io.IOException;
import java.net.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openrdf.model.Value;
import org.openrdf.sesame.config.AccessDeniedException;
import org.openrdf.sesame.config.ConfigurationException;
import org.openrdf.sesame.config.UnknownRepositoryException;
import org.openrdf.sesame.query.MalformedQueryException;
import org.openrdf.sesame.query.QueryEvaluationException;
import org.openrdf.sesame.repository.*;
import org.openrdf.sesame.Sesame;
import org.openrdf.sesame.admin.AdminListener;
import org.openrdf.sesame.admin.StdOutAdminListener;
import org.openrdf.sesame.constants.QueryLanguage;
import org.openrdf.sesame.constants.RDFFormat;
import org.openrdf.sesame.query.QueryResultsTable;
import org.openrdf.sesame.repository.local.LocalRepository;


public class Connection {
   private String login;
   private String passwd;
   private String url;
   private SesameService service = null;
   private SesameRepository myRepository = null;
   
   /**
    * Constructor; sets variables
    * @param login
    * @param passwd
    * @param url
    */
   public Connection(String login, String passwd, String url) {
       this.login = login;
       this.url = url;
       this.passwd = passwd;
   
   }
   
   
   /** 
    * @param login
    * @param passwd
    * @param url
    * @return 0 if successfull
    */
   public int sesameConnect() {
       try {
           java.net.URL sesameServerURL = new java.net.URL(url);
           service = Sesame.getService(sesameServerURL);
           service.login(login, passwd);

       } catch (AccessDeniedException ex) {
           System.err.println("Access to Sesame server denied, bad login or password.");
           return 1;
       } catch (MalformedURLException ex) {
           System.err.println("Malformed Sesame URL.");
           return 1;
       } catch (IOException ex) {
           System.err.println("IO error. Is Sesame server running?");
           Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
           return 1;
       }
       System.out.println("Přihlášeno ke službě Sesame"); 
       return 0;
   }//sesameConnect

   
   public void sesameDisconnect() {
       try {
           service.logout();
       } catch (IOException ex) {
           System.err.println("Couldn't log out, IO error.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       }
   }
   
   /**
    * Selects repository on the server, we are connected to
    * @return 0 when successfull
    */
   public int repositorySelect(String repoID){
       try {
           myRepository = service.getRepository(repoID);
           
       } catch (UnknownRepositoryException ex) {
           System.err.println("Unknown repository. Check your spelling.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
           return 1;
       } catch (ConfigurationException ex) {
           System.err.println("Repository configuration error.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
           return 1;
       } catch (IOException ex) {
           System.err.println("IO error.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
           return 1;
       }
   
       return 0;
   }//repositorySelect
   
   
   /**
    * Run query on repository
    * Writes table of results on standard output
    */
   public void query (String query) {
       try {
           QueryResultsTable resultsTable = myRepository.performTableQuery(QueryLanguage.SERQL, query);
           int rowCount = resultsTable.getRowCount();
           int columnCount = resultsTable.getColumnCount();
           for (int row = 0; row < rowCount; row++) {
               for (int column = 0; column < columnCount; column++) {
                   Value value = resultsTable.getValue(row, column);
                   if (value != null) {
                       System.out.print(value.toString());
                   } else {
                       System.out.print("null");
                   }
                   System.out.print("\t");
               }
               System.out.println();
           }

       } catch (MalformedQueryException ex) {
           System.err.println("Malformed query.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       } catch (QueryEvaluationException ex) {
           System.err.println("Evaluation exception");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       } catch (AccessDeniedException ex) {
           System.err.println("Acces denied.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       } catch (IOException ex) {
           System.err.println("IO error");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       }
   }
   
   /**
    * Adding another data into repository
    */
   public void addData() {
       try {
           java.net.URL myRDFData = new java.net.URL("http://localhost/instance.rdf");
           String baseURI = "http://fi.muni.cz/fakulta#";
           boolean verifyData = true;
           AdminListener myListener = new StdOutAdminListener();
           myRepository.addData(myRDFData, baseURI, RDFFormat.RDFXML, verifyData, myListener);
                   
                   
       } catch (MalformedURLException ex) {
           System.err.println("URL doesn't exist or malformed. Check your spelling.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       } catch (AccessDeniedException ex) {
           System.err.println("Access denied while adding RDF data.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       } catch (IOException ex) {
           System.err.println("IO error while adding RDF data.");
           Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);
       }
   }
   

} //class



package cz.muni.fi.xtalas1.sesameapi;

public class Main {

   /**
    * Main program loader
    * @param args
    */
public static void main(String[] args) {
       int result = 0;
       System.out.println("Nastavuji konfiguraci");
       Connection sesameCon = new Connection("xtalas","xtalas","http://localhost:8080/sesame");
       
       //try connection to sesame
       result = sesameCon.sesameConnect();
       if (result == 1) {
           System.err.println("Fatal error: couldn't connect to Sesame. Exiting.");
           System.exit(1);
       }
       
       //open repository
       result = sesameCon.repositorySelect("mysql_fakulta");
       if (result == 1) {
           System.err.println("Fatal error: could't find this repository. Exiting.");
           System.exit(1);
       }
       
       System.out.println("Connected to the repository.");
       
       //sesameCon.addData();
       //System.out.println("Data added successfuly.");
       sesameCon.query("SELECT * FROM {x} p {y}");
       sesameCon.sesameDisconnect();
       
   } //metoda main

}//class Main