GraphDB-SE Installation Guide

This section is for users and system administrators that are unfamiliar with the GraphDB-SE semantic repository software. The information contained in the following pages should be enough to get started with GraphDB-SE, i.e. to install and configure the software so that repository instances can be created and used.
{toc}

h1. Usage scenarios

GraphDB-SE is packaged as a Storage and Inference Layer (SAIL) for the [Sesame RDF framework|http://www.openrdf.org/]. GraphDB-SE can be used in two different ways:
* *Library:* One approach is to integrate GraphDB in an application using it as a library. An example of doing this is given in the 'getting-started' folder of the GraphDB-SE distribution zip file. Users intending to use GraphDB-SE in this way do not need to install the Sesame Web applications (Server and Workbench) and need only set a few environment variables as detailed in the [configuration section of the GraphDB-SE user guide|GraphDB-SE Configuration#Getting-Started Application].
* *Server:* Those users wishing to use GraphDB-SE via the Sesame Server, with or without the Sesame Workbench, should proceed with one of the two approaches detailed in this section. This will cover installing Sesame and integrating GraphDB-SE in to the Sesame framework, so that GraphDB-SE can be used as a plug-in repository type. This approach involves deploying Sesame/GraphDB-SE via a servlet server, such as Tomcat. The Sesame installation comes with a useful 'workbench' Web application that can be used for many administration tasks.

The rest of this section gives detailed step by step instructions for installing and configuring Sesame and GraphDB-SE, leading up to the creation of a GraphDB-SE repository using the Sesame console (a command line script). For more information please check the "doc" folder of the GraphDB-SE distribution zip file.

h1. Upgrading

In most cases, upgrading GraphDB-SE can be achieved simply by replacing the GraphDB and bundled 3rd party jar files. The required version of the Sesame framework for the recent OWLIM versions is given in the following table:

|| OWLIM/GraphDB version || Required Sesame version ||
| GraphDB-SE 6.0 | Sesame 2.7.8 + new index format (autoupgraded) - the same for Owlim 5.5|
| OWLIM-SE 5.5 | Sesame 2.7.8 + new index format (autoupgraded)|
| OWLIM-SE 5.4 | Sesame 2.7.8 |
| OWLIM-SE 5.3 | Sesame 2.6.7\+ |
| OWLIM-SE 5.2 | Sesame 2.6.7\+ |
| OWLIM-SE 5.1 | Sesame 2.6 |
| OWLIM-SE 5.0 | Sesame 2.6 |
| OWLIM-SE 4.3 | Sesame 2.6 |
| OWLIM-SE 4.2 | Sesame 2.5 |
| OWLIM-SE 4.1 | Sesame 2.4 |
| OWLIM-SE 4.0 | Sesame 2.4 |
| BigOWLIM 3.5 | Sesame 2.3 |
| BigOWLIM 3.4 | Sesame 2.3 |
| BigOWLIM 3.3 | Sesame 2.3 |
| BigOWLIM 3.2 | Sesame 2.3 |
| BigOWLIM 3.1 | Sesame 2.2 |

Sometimes, the binary format of the storage files for different versions of BigOWLIM/OWLIM-SE/GraphDB-SE are not compatible. However, storage files created with version 3.1 and upwards will be automatically upgraded when using a later version of Owlim/GraphDB. However, this is a one-way process and no downgrade facility is provided.

{warning}
When upgrading to a later version of Owlim/GraphDB it is vitally important to make a back-up of your storage files before running the new software, because, otherwise, it will be impossible to revert to a previous version of GraphDB.
{warning}

* *openrdf-workbench.war:* The GraphDB-SE jar, XSLT configuration code and a GraphDB-SE Turtle configuration file have been added, so that new GraphDB-SE instances can be created using the Workbench without the need to run the command line console application.

After deployment, a GraphDB-SE instance can be created using the workbench application as follows:
* Start a browser and go to the Workbench Web application using a URL of this form: [http://localhost:8080/openrdf-workbench/] \- substituting {{localhost}} and the {{8080}} port number as appropriate.
* Click 'change server' if necessary to select a Sesame server instance if it is running on a different machine. The server URL will be of this form: [http://localhost:8080/openrdf-sesame]
* After selecting a server, click 'New repository'
* Select 'GraphDB-SE' from the drop-down and enter the repository ID and description. Then click 'next'.
* Fill in the fields as required (referring to the owlim-configurator spreadsheet as necessary) and click 'create' - if you have a GraphDB-SE license file, its location should be specified in the license field. Note that paths must use '/' separators, even on Windows.
* A message should be displayed that gives details of the new repository and this should also appear in the repository list (click 'repositories' to see this).

{info}
All configuration parameters that accept file/path names must use forward slashes ('/') even on Windows systems.
{info}

h1. Longer install

This longer install process should be used when a different or modified version of Sesame is being used. In this case, all the GraphDB-SE files need to be installed alongside Sesame in a step-by-step process as follows.

h2. Preparation

A suitable application server must be installed. The examples in this guide assume [Apache Tomcat|http://tomcat.apache.org/] version 6.x is used. Importantly, the user must have sufficient privileges to write to the Tomcat {{webapps}} directory and to stop and start the Tomcat daemon.
A [GraphDB-SE|http://www.ontotext.com/products/ontotext-graphdb/graphdb-standard/] distribution is required. This is published as a zip file and includes the [Lucene|http://lucene.apache.org/] (core) full-text search utility jar file. The examples in this guide use version 6.
If desired, the core version of Lucene can be replaced with the full Lucene jar that is available for download from the [Lucene website|http://lucene.apache.org/].
The [Aduna OpenRDF Sesame framework version 2.4|http://www.openrdf.org/] is required for the longer installation. The examples in this guide use version 2.7.

{note}Another application server can be used instead of Tomcat. However, the rest of this guide describes the installation of GraphDB-SE with this software.
{note}No part of this guide is intended to supersede the documentation published with these 3{^}rd^ party software components and the reader is strongly advised to familiarise himself/herself with these.


h2. Installation

Assuming that an instance of Tomcat is available, the installation proceeds as follows:
* Install and deploy Sesame;
* Install GraphDB-SE and deploy GraphDB-SE and other 3{^}rd^ party jar files (including Lucene-core);
* Add the GraphDB-SE repository template file to the Sesame console configuration;
* Use the Sesame console to create a new repository;
* Set up a license file if you have one.

h3. Step by step (vanilla)

* Locate the Tomcat webapps directory, hereafter called \[WEBAPPS\].
* Unzip the Sesame 2 distribution zip file. The Sesame 'root' directory will be called \[SESAME\].
* Unzip the GraphDB-SE distribution. The top level unzipped directory will be called \[GraphDBSE\].
* Deploy the Sesame Web applications by copying the war files in \[SESAME\]/war to \[WEBAPPS\].

{note}
Alternatively, use the Tomcat manager interface at {{[http://localhost:8080/manager/html]}} to deploy the Web applications. If this approach is used, then ensure that a manager user account exists. The following lines should be added to: {{\[tomcat-directory\]/conf/tomcat-users.xml}} substituting your own password:
{code:xml}<tomcat-users>
<role rolename="manager"/>
<user username="tomcat" password="pass" roles="manager"/>
</tomcat-users>
{code}
{note}

* Restart Tomcat;
* Run the Sesame console once to create its configuration directory by executing {{\[SESAME\]/bin/console.sh}} (.bat) and then type {{quit .}} at the command prompt;
* Locate the data directory here:
{noformat}$HOME/.aduna/openrdf-sesame-console* (linux/unix)
"%APPDATA%\Aduna\OpenRDF Sesame console" (Windows)
"$HOME/Library/Application Support/Aduna/OpenRDF Sesame console" (Mac OS X)
{noformat}
* Create the {{templates}} folder here and copy the GraphDB-SE repository template to it. This file is found here: {{\[GraphDBSE\]/templates/owlim-se.ttl}};
* Copy the GraphDB-SE jar file to the Sesame console and Sesame server, i.e. from {{\[GraphDBSE\]/lib}} to {{\[SESAME\]/lib}} and {{\[WEBAPPS\]/openrdf-sesame/WEB-INF/lib}};
* Copy the Lucene and other 3{^}rd^ party jars to the Sesame server, i.e, from {{\[GraphDBSE\]/ext}} to {{\[WEBAPPS\]/openrdf-sesame/WEB-INF/lib}};
* Restart Tomcat;
* Run the Sesame console {{\[SESAME\]/bin/console.sh (.bat)}};
* Connect to the local Sesame server with: {{connect}} {{[http://localhost:8080/openrdf-sesame]}} {{.}};
* Create a new repository: {{create owlim-se.}};
* Accept all the default values and then exit the console: {{quit.}}

The status of the new repository can be checked using the Sesame workbench. Type the following URL in to a browser:
{noformat}http://localhost:8080/openrdf-workbench{noformat}

h3. Step by step (Fedora linux)

* Login as root and ensure that tomcat is running: {noformat}service tomcat6 status{noformat}
* Unzip the Sesame 2 installation: {noformat}unzip openrdf-sesame-2.*-sdk.zip{noformat}
* Deploy the Sesame Web applications (Sesame server and workbench): {noformat}cp openrdf-sesame-2.*/war/*.war /var/lib/tomcat6/webapps/{noformat}
* Restart Tomcat: {noformat}service tomcat6 restart{noformat}
* Run the Sesame console once to create the data/configuration directory: {noformat}openrdf-sesame-2.*/bin/console.sh{noformat}
* And exit: {noformat}quit .{noformat}
* Create the Sesame console's templates directory: {noformat}mkdir $HOME/.aduna/openrdf-sesame-console/templates{noformat}
* Unzip the GraphDB-SE distribution: {noformat}unzip owlim-se-5.*.zip{noformat}
* Copy the GraphDB-SE repository template file to the Sesame console templates directory:
{noformat}cp owlim-se-5*/templates/owlim-se.ttl $HOME/.aduna/openrdf-sesame-console/templates/{noformat}
* Copy the GraphDB-SE jar file to the Sesame console lib directory: {noformat}cp owlim-se-5*/lib/owlim-se*.jar openrdf-sesame-2.*/lib/{noformat}
* Copy the GraphDB-SE jar file to the Sesame server lib directory: {noformat}cp owlim-se-5*/lib/owlim-se*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/{noformat}
* Copy the Lucene jar file the other 3{^}rd^ party jar files to the Sesame server Web application:
{noformat}
cp owlim-se-5*/ext/log4j*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/
cp owlim-se-5*/ext/lucene*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/
cp owlim-se-5*/ext/onto-jsi*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/
cp owlim-se-5*/ext/onto-crypto*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/
cp owlim-se-5*/ext/sil*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/
cp owlim-se-5*/ext/trove4j*.jar /var/lib/tomcat6/webapps/openrdf-sesame/WEB-INF/lib/
{noformat}
* Restart Tomcat: {noformat}service tomcat6 restart{noformat}
* Run the Sesame console to create a new repository: {noformat}openrdf-sesame-2.*/bin/console.sh{noformat}
* Connect to the Sesame server: {noformat}connect http://localhost:8080/openrdf-sesame .{noformat}
* Create a new repository: {noformat}create owlim-se .{noformat}
* At this point values for a number of parameters are asked for, but all the defaults can be accepted by pressing {{<return>}} for each question. When finished, the message 'Repository created' should be displayed.
* Exit the console: {noformat}quit .{noformat}
* The status of the new repository can be checked using the Sesame workbench. Type the following URL in to a browser: {noformat}http://localhost:8080/openrdf-workbench{noformat}
* Alternatively, execute a test query against the Sesame Server's SPARQL endpoint:
{noformat}
curl -H "Accept: application/sparql-results+json"
'http://localhost:8080/openrdf-sesame/repositories/owlim-se-test?infer=false&queryLn=sparql&
query=SELECT+*+WHERE+%7B?s+?p+?o%7D+LIMIT+100'
{noformat}

h3. Step by step (Windows)

* Unzip the Sesame 2 installation (note that this might require WinZIP, WinRAR or some other utility): {noformat}unzip openrdf-sesame-2.7.2-sdk.zip{noformat}
* Deploy the Sesame Web applications (Sesame server and workbench): {noformat}copy openrdf-sesame-2.7.2\war\*.war "C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps"{noformat}
* Restart Tomcat using the Tomcat monitor icon in the system tray or from the Start menu
* Run the Sesame console once to create the data/configuration directory: {noformat}openrdf-sesame-2.7.2\bin\console.bat{noformat}
* Then exit immediately: {noformat}quit .{noformat}
* Create the Sesame console's templates directory: {noformat}mkdir "%APPDATA%\Aduna\OpenRDF Sesame console\templates"{noformat}
* Unzip the GraphDB-SE distribution: {noformat}unzip owlim-se-5*.zip{noformat}
* Copy the GraphDB-SE repository template file to the Sesame console templates directory: {noformat}copy owlim-se-5.4.6200\templates\owlim-se.ttl "%APPDATA%\Aduna\OpenRDF Sesame console\templates"{noformat}
* Copy the GraphDB-SE jar file to the Sesame console and Sesame server lib directories:
{noformat}
copy owlim-se-5.4.6200\lib\owlim-se-5*.jar openrdf-sesame-2.7.2\lib
copy owlim-se-5.4.6200\lib\owlim-se-5*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
{noformat}
* Copy the Lucene and other 3{^}rd^ party jar files to the Sesame server Web application:
{noformat}
copy owlim-lite-5.4.6200\ext\log4j*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
copy owlim-lite-5.4.6200\ext\lucene*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
copy owlim-lite-5.4.6200\ext\onto-jsi*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
copy owlim-lite-5.4.6200\ext\onto-crypto*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
copy owlim-lite-5.4.6200\ext\sil*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
copy owlim-lite-5.4.6200\ext\trove*.jar
"C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\openrdf-sesame\WEB-INF\lib"
{noformat}
* Restart Tomcat using the Tomcat monitor icon in the system tray or from the Start menu
* Run the Sesame console to create a new repository: {noformat}openrdf-sesame-2.7.2\bin\console.bat{noformat}
* Connect to the Sesame server: {noformat}connect http://localhost:8080/openrdf-sesame.{noformat}
* Create a new repository: {noformat}create owlim-se .{noformat}
* At this point values for a number of parameters are asked for, but all the defaults can be accepted pressing {{<return>}} for each question. When finished, the message 'Repository created' should be displayed, so exit the console: {noformat}quit .{noformat}
* The status of the new repository can be checked using the Sesame workbench. Type the following URL in to a browser: {noformat}http://localhost:8080/openrdf-workbench/{noformat}

h1. Useful information


h2. Tomcat

When running on Fedora linux, Tomcat uses the following directories:
|| Contents || Directory ||
| Log files | {{/var/log/tomcat6/}} |
| Web applications | {{/var/lib/tomcat6/webapps}} |
| Sesame configuration, repository data files and logs | {{/usr/share/tomcat6/.aduna}} |
On a machine running Windows, Tomcat uses the following directories:
|| Contents || Directory ||
| Log files | {{C:\Program Files\Apache Software Foundation\Tomcat 6.0\logs}} |
| Web applications | {{C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps}} |
| Sesame configuration, repository data files and logs | {{C:\Users\<username>\AppData\Roaming\Aduna}} |


h2. Sesame

The Sesame framework is published as a zip file,which is installed simply by unzipping it in to the target directory. This directory is called \[SESAME_INSTALL\] in this guide.
When running, Sesame stores configuration and repository data in the following directory:
| {{$HOME/.aduna/}} | On linux/unix operating systems. |
| {{%APPDATA%\Aduna\}} | On Windows machines. Note that if Sesame is running as a service then the full path will be: \\
{{C:\Documents and Settings\LocalService\Application Data\Aduna\}} |
This directory is called \[ADUNA_DATA\] elsewhere in this guide. It can be overridden by setting a Java system property. When using Tomcat, this can be achieved by setting the JAVA_OPTS environment variable, for example (linux and Windows respectively):
{noformat}export JAVA_OPTS='-Dinfo.aduna.platform.appdata.basedir=/other/dir/'
set JAVA_OPTS=-Dinfo.aduna.platform.appdata.basedir=\other\dir\
{noformat}Note that setting this environment variable must be done by the same user that runs the Tomcat server. This may not be the case when using 'sudo' to set up/start Tomcat, for instance when using port numbers below 1024, when it is necessary to run Tomcat with root privileges.
The Sesame 2 framework uses a special SYSTEM repository to store its configuration data. Do not store anything else in this repository.
The workbench Web application can be used for many administrative tasks, but it is still experimental. The easiest method to create new repositories is to use the Sesame Console script, which can be found in the bin directory: {{\[SESAME_INSTALL\]/bin/console.bat}} (.sh for linux/unix)
{note}All commands entered using the console must end in a dot '.', e.g. 'help.'
{note}

h2. Logging

The Sesame server and workbench use SLF4J for logging, although they each map to different underlying logging implementations. The Sesame server has bindings to [logback|http://logback.qos.ch/], whereas the Sesame workbench has bindings to the Java Runtime logging framework. By default, the Sesame server logs to:
{noformat}[ADUNA_DATA]/openrdf-sesame/logs/main.log{noformat}

The default log level is INFO, but this can be adjusted after the first run by editing:
{noformat}[ADUNA_DATA]/openrdf-sesame/conf/logback.xml{noformat}

GraphDB also uses SLF4J for logging and the distribution includes the SLF4J-to-Java-logging mapping jar file. The repackaged openrdf-sesame war file that comes with GraphDB does not have this mapping, so in this case GraphDB logs as Sesame does to the logback framework.

Tomcat uses log4j and the logging details can set up by editing this file (on Linux):
{noformat}/var/lib/tomcat6/conf/logging.properties{noformat}
or this file on Windows:
{noformat}C:\Program Files\Apache Software Foundation\Tomcat 6.0\conf\logging.properties{noformat}

By default, the Tomcat logs (on Linux) are written to:
{noformat}/var/log/tomcat6/{noformat}
and the logs (on Windows) are written to:
{noformat}C:\Program Files\Apache Software Foundation\Tomcat 6.0\logs{noformat}

h1. Common Problems

h4. Can not copy GraphDB-SE jar file to the Sesame WEB-INF/lib directory.

This directory will not exist until the Sesame war files have been deployed to the \[WEBAPPS\] directory AND Tomcat is running. If the war files have been deployed, but the directory does not exist, try restarting Tomcat.

h4. Can not connect the Sesame console to the local Sesame server at {{[http://localhost:8080/openrdf-sesame]}}

Make sure that the Sesame war files have been deployed and that Tomcat is running. Restart Tomcat if necessary.

h4. Can not create a GraphDB-SE repository using the Sesame console

Make sure that the repository template file GraphDBSE/templates/owlim-se.ttl has been copied to the 'templates' subdirectory of the Sesame console's data directory.

h4. Can not create a GraphDB-SE repository, the Sesame console says unknown Sail type -- owlim:Sail

The Sesame console can not find the GraphDB-SE jar file. Make sure it was copied from GraphDBSE/lib to the Sesame installation folder here: SESAME/lib

h4. A long error message/Java exception is given when trying to query a new repository instance.

The Lucene jar file must be copied from the GraphDB-SE distribution to the Sesame server's WEB-INF/lib directory. Restart Tomcat if necessary.

h4. Cannot use my custom rule file (pie file), an exception occurred

The tools.jar file from the Java Development Kit (JDK) must be on the classpath or alternatively copied to Sesame server's WEB-INF/lib directory.

h4. Sesame Workbench starts, but gives memory error on the 'explore' and 'query' menus.

The maximum heap space must be increased, i.e. Tomcat's Java virtual machine must be allowed to allocate more memory. This can be done by setting the environment variable 'CATALINA_OPTS' to include the desired value, e.g. \-Xmx1024m

h1. Installing GraphDB-SE with Jena

This section is for users and system administrators that are unfamiliar with the GraphDB-SE Jena adapter. The information contained in the following pages should be enough to get started with this software, i.e. to install and configure a GraphDB-SE repository and access it via the Jena API or Jena compatible tools.
{note}
The Jena adapter allows GraphDB-SE to be used with local repositories, NOT those shared via the Sesame HTTP server. If you want to use GraphDB-SE remotely, consider using the Joseki server as described below.
{note}

h2. Required software

This guide covers installing and configuring the Jena adapter for [GraphDB-SE|http://www.ontotext.com/products/ontotext-graphdb/graphdb-standard/]. Required software for this comprises:
* [Jena|https://repository.apache.org/content/repositories/releases/org/apache/jena/jena-core/] version 2.7 (tested with version 2.7.3)
* [ARQ|https://repository.apache.org/content/repositories/releases/org/apache/jena/jena-arq/] (tested with version 2.9.3)

No part of this guide is intended to supersede the documentation published with these software components and the reader is strongly advised to familiarise himself/herself with these.

h2. Description of the GraphDB-SE Jena adapter

The GraphDB-SE Jena adapter is essentially an implementation of the [Jena|http://jena.sourceforge.net/index.html] _DatasetGraph_ interface that provides access to individual triples managed by a GraphDB-SE repository through the Sesame API interfaces.
It is not a general purpose Sesame adapter and cannot be used to access any Sesame compatible repository, because it utilises an internal GraphDB-SE API to provide more efficient methods for processing RDF data and evaluating queries.
The adapter comes with its own implementation of a [Jena|http://jena.sourceforge.net/index.html] 'assembler' factory to make it easier to instantiate and use with those related parts of the Jena framework, although one can instantiate an adapter directly by providing an instance of a Sesame *SailRepository* (a GraphDB-SE *GraphDBRepository* implementation). Query evaluation is controlled by the ARQ engine, but specific parts of a Query (mostly batches of statement patterns) are evaluated natively through a modified *StageGenerator* plugged into the Jena runtime framework for efficiency. This also avoids unnecessary cross-api data transformations during query evaluation.

h2. Instantiate Jena adapter using a SailRepository

In this approach, a GraphDB-SE repository is first created and wrapped in a Sesame *SailRespository*. Then a connection to it is used to instantiate the adapter class *SesameDataset*. The following example helps to clarify:
{code}import com.ontotext.trree.OwlimSchemaRepository;
import org.openrdf.repository.sail.SailRepository;
import org.openrdf.repository.RepositoryConnection;
import com.ontotext.jena.SesameDataset;

...

OwlimSchemaRepository schema = new OwlimSchemaRepository();

// set the data folder where GraphDB-SE will persist its data
schema.setDataDir(new File("./local-sotrage"));

// configure GraphDB-SE with some parameters
schema.setParameter("storage-folder", "./");
schema.setParameter("repository-type", "file-repository");
schema.setParameter("ruleset", "rdfs");

// wrap it into a Sesame SailRepository
SailRepository repository = new SailRepository(schema);

// initialize
repository.initialize();
RepositoryConnection connection = repository.getConnection();

// finally, create the DatasetGraph instance
SesameDataset dataset = new SesameDataset(connection);
{code}From now on the {{SesameDataset}} object can be used through the Jena API as regular Dataset, e.g. to add some data into it one could do something like the following:
{code}Model model = ModelFactory.createModelForGraph(dataset.getDefaultGraph());
Resource r1 = model.createResource("http://example.org/book#1") ;
Resource r2 = model.createResource("http://example.org/book#2") ;

r1.addProperty(DC.title, "SPARQL - the book")
.addProperty(DC.description, "A book about SPARQL") ;

r2.addProperty(DC.title, "Advanced techniques for SPARQL") ;
{code}and can also be used to evaluate queries through the ARQ engine:
{code}// Query string.
String queryString = "PREFIX dc: <" + DC.getURI() + "> " +
"SELECT ?title WHERE {?x dc:title ?title . }";

Query query = QueryFactory.create(queryString);

// Create a single execution of this query, apply to a model
// which is wrapped up as a QueryExecution and then fetch the results
QueryExecution qexec = QueryExecutionFactory.create(query, dataset.asDataset());
try {
// Assumption: it's a SELECT query.
ResultSet rs = qexec.execSelect();
// The order of results is undefined.
for (; rs.hasNext();) {
QuerySolution rb = rs.nextSolution();
for (Iterator<String> iter = rb.varNames(); iter.hasNext();) {
String name = iter.next();
RDFNode x = rb.get(name);
if (x.isLiteral()) {
Literal titleStr = (Literal) x;
System.out.print(name + "=" + titleStr + "\t");
} else if (x.isURIResource()) {
Resource res = (Resource) x;
System.out.print(name + "=" + res.getURI() + "\t");
}
else
System.out.print(name + "=" + x.toString() + "\t");
}
System.out.println();
}
}
catch( Exception e ) {
System.out.println( "Exception occurred: " + e );
}
finally {
// QueryExecution objects should be closed to free any system resources
qexec.close();
}
{code}

h2. Instantiate GraphDB-SE adapter using the provided Assembler

Another approach is to use the Jena assemblers infrastructure to instantiate a GraphDB-SE Jena adapter. For this purpose the required configuration must be stored in some valid RDF serialisation format and its contents read into a Jena model. Then, the assembler can be invoked to get an instance of the Jena adapter. The following example specifies an adapter instance in N3 format.

{noformat}
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#> .
@prefix otjena: <http://www.ontotext.com/jena/> .

@prefix : <#> .

[] ja:loadClass "com.ontotext.jena.SesameVocab" .
otjena:SesameDataset rdfs:subClassOf ja:Object .
otjena:SesameDataset ja:assembler "com.ontotext.jena.SesameAssembler" .
<#dataset> rdf:type otjena:SesameDataset ;
otjena:datasetParam "./location" .
{noformat}
The {{ja:loadClass\*}} statements ensure that the GraphDB-SE Jena adapter factory class file(s) are initialised and plugged into the Jena framework prior to being invoked. Then the *\#dataset* description tells the Jena framework to expect instances of *otjena:SesameDataset* to be created by this factory. The following example uses such a description stored in the file *owlimbridge.n3* to get an instance of the Jena adapter:

{code:xml}
Model spec = FileManager.get().loadModel( "owlimbridge.n3" );
Resource root = spec.createResource( spec.expandPrefix( ":dataset" ) );
DataSource datasource = (DataSource)Assembler.general.open( root );
DatasetGraph dataset = datasource.asDatasetGraph();
{code}
After this, the adapter is ready to be used, for example to evaluate some query through the ARQ engine using the same approach described a few paragraphs above.

h2. Using GraphDB-SE with the Joseki server

In order to use a GraphDB-SE repository with the Joseki server one needs only to configure it as a dataset, so that the Jena assembler framework is able to instantiate it. An example Joseki configuration file that makes use of such a dataset description could looks like the following. First we describe a service that hosts the dataset:

{noformat}<#service1>
rdf:type joseki:Service ;
rdfs:label "service point" ;
joseki:dataset otjena:bridge ;
joseki:serviceRef "sparql" ;
joseki:processor joseki:ProcessorSPARQL ;
.
{noformat}

Then we describe that dataset:

{noformat}
[] ja:loadClass "com.ontotext.jena.SesameVocab" .
otjena:DatasetSesame rdfs:subClassOf ja:RDFDataset .
otjena:bridge rdf:type otjena:DatasetSesame ;
rdfs:label "GraphDB-SE repository" ;
otjena:datasetParam "./location" .
{noformat}

h1. Using GraphDB-SE with TopBraid Composer

All versions of GraphDB can be used with [TopBraid Composer/Live|http://www.topquadrant.com/products/TB_Suite.html], when set up using the Sesame HTTP server. When running TopBraid Composer, simply select File->New...->RDF/OWL Sesame2 RDF Repository Connection and enter the details (most importantly the server URL and repository ID).

However, TopBraid Composer can also use GraphDB-SE embedded, i.e. without needing to set up a server. To use TopBraid Composer and GraphDB-SE in this way, two components need to be installed:

* The GraphDB-SE bundle for TopBraid Composer - provided separately from Ontotext via a download
* The GraphDB-SE connector - installed using the eclipse update manager

The outline of the steps needed are as follows:

# Download the GraphDB bundle from Ontotext and copy it to the TopBraid Composer 'plugins' directory;
# Restart TopBraid Composer;
# Use the update manager to install the "GraphDB connector for TopBraid" from [http://www9.ontotext.com].

From now on GraphDB can be used with TBC in several ways as described below.

# Create a GraphDB database:
## Select File->New->Other... then type GraphDB (to reduce the options) and then choose "RDF/OWL Local Owlim Database";
## Make any changes to the default configuration and press 'Create';
## Select in navigator view and open;
## It is now possible to use the SPARQL query view.

# Export to a GraphDB database:
## Open an ontology file;
## Select File->export->TopBraid Composer->Export/Merge/Convert RDF graphs;
## Choose "RDF/OWL Local Owlim Database";
## Complete the configuration.

h2. Memory requirements

The default settings for TBC give it a rather small heap space, which is only suitable for small databases. Edit the file "TopBraid Composer.ini" in TBC's install directory and change the following two settings as shown:

{noformat}
-XX:MaxPermSize=512m
-Xmx2048M
{noformat}

Increase {{\-Xmx}} for larger databases.