GraphDB

https://graphdb.ontotext.com/documentation/11.1
Admin
GraphDB is a highly efficient, scalable, and robust graph database (triplestore) with RDF and SPARQL...
Tokens:653,731
Snippets:9,396
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Basic entity filter example setup

Source: https://graphdb.ontotext.com/documentation/11.1/elasticsearch-graphdb-connector.html

This section introduces an example using RDF data to illustrate basic entity filtering concepts.

```turtle
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix example: <http://www.ontotext.com/example#> .

```

--------------------------------

### Build the example JAR

Source: https://graphdb.ontotext.com/documentation/11.1/helloworld.html

Compile and package the example code into a JAR file using Maven.

```bash
mvn install

```

--------------------------------

### Start Solr Server

Source: https://graphdb.ontotext.com/documentation/11.1/solr-graphdb-connector.html

Execute this command to start a Solr instance, specifying the port and Solr home directory.

```bash
<path-to-solr-distribution>/bin/solr start -p 8934 -s /<path-to-solr-home>
```

--------------------------------

### Build the Example App with Maven

Source: https://graphdb.ontotext.com/documentation/11.1/familyrelations.html

Use this Maven command to build the example application. Ensure the pom.xml is configured correctly to point to the FamilyRelationsApp class.

```bash
mvn install
```

--------------------------------

### Kerberos Authentication Example

Source: https://graphdb.ontotext.com/documentation/11.1/access-control.html

Example configuration for enabling Kerberos authentication in conjunction with local user database authorization.

```properties
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ KERBEROS AUTHENTICATION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```

--------------------------------

### Passive Health Check Example (Repository Initializing)

Source: https://graphdb.ontotext.com/documentation/11.1/database-health-checks.html

This JSON output shows the health status when a repository is currently initializing, indicated by a 'STARTING' state.

```json
{
   "status" : "yellow",
   "components" : [
      {
         "status" : "yellow",
         "name" : "repository-state",
         "message" : "STARTING"
      }
   ],
   "name" : "test"
}
```

--------------------------------

### GraphDB Configured Directories Log Output

Source: https://graphdb.ontotext.com/documentation/11.1/directories-and-config-properties.html

This is an example of the log output when GraphDB starts, showing the actual values for the GraphDB home, configuration, data, work, and logs directories.

```text
GraphDB Home directory: /path-to-graphdb/app
GraphDB Config directory: /path-to-graphdb/app/conf
GraphDB Data directory: /path-to-graphdb/app/data
GraphDB Work directory: /path-to-graphdb/app/work
GraphDB Logs directory: /path-to-graphdb/app/logs
```

--------------------------------

### Start GraphDB External Proxy

Source: https://graphdb.ontotext.com/documentation/11.1/creating-a-cluster.html

This snippet shows how to start the external proxy for GraphDB. Ensure the necessary configurations are in place before execution.

```bash
bin/graphdb-proxy
```

--------------------------------

### Another Film Role Example

Source: https://graphdb.ontotext.com/documentation/11.1/_downloads/d76db51eac502d4fda56494b4ab80a03/starwars-data.ttl

Another instance of a film role, linking a person to a film with the role of 'cast member'.

```turtle
wds:Q6074-4994E781-E4DC-48D6-A525-C33214CA34B4
    a                 voc:FilmRole ;
    voc:film          <film/7> ;
    voc:person        wd:Q456047 ;
    voc:role          "cast member" ;
    voc:wikidataLink  wds:Q6074-4994E781-E4DC-48D6-A525-C33214CA34B4 .
```

--------------------------------

### Film Role Example

Source: https://graphdb.ontotext.com/documentation/11.1/_downloads/d76db51eac502d4fda56494b4ab80a03/starwars-data.ttl

Represents a film role with character, film, person, and role details. Includes a wikidataLink for external reference.

```turtle
wds:Q6074-42A373D8-7B48-4B47-B937-C7A9DABF4B4B
    a                 voc:FilmRole ;
    voc:character     <human/85> ;
    voc:film          <film/7> ;
    voc:person        wd:Q16738674 ;
    voc:role          "cast member" ;
    voc:wikidataLink  wds:Q6074-42A373D8-7B48-4B47-B937-C7A9DABF4B4B .
```

--------------------------------

### Generate Bindings with spif:for

Source: https://graphdb.ontotext.com/documentation/11.1/sparql-ext-functions-reference.html

Use `spif:for` to generate integer bindings between a start and end value. The example shows how to get values from 6 to 8.

```sparql
PREFIX spif: <http://spinrdf.org/spif#>

SELECT ?result WHERE {
  ?result spif:for (6 8)
}
```

--------------------------------

### Example Annotation Progress Log Message

Source: https://graphdb.ontotext.com/documentation/11.1/text-mining-plugin.html

This is an example log message indicating the start of document annotation, showing the document's starting content and length.

```log
[DEBUG] 2021-05-19 08:39:40,893 [repositories/ff-news | c.o.g.p.t.c.ClientBase] Annotating document content starting with: "Australia's Cardinal Pell sentenced to six years jail for sexually... MELBOURNE (Reuters) - Former ..." with length: 911

```

--------------------------------

### Run the Example App JAR

Source: https://graphdb.ontotext.com/documentation/11.1/familyrelations.html

Execute the built JAR file to run the FamilyRelationsApp. This command assumes the JAR file is named dev-examples-1.0-SNAPSHOT.jar.

```bash
java -jar dev-examples-1.0-SNAPSHOT.jar
```

--------------------------------

### Clone and Run GraphDB Workbench

Source: https://graphdb.ontotext.com/documentation/11.1/extend-workbench.html

Clone the GraphDB Workbench project from GitHub, install dependencies, and start the development server. This command starts a webpack development server that proxies REST requests to GraphDB.

```bash
git clone https://github.com/Ontotext-AD/graphdb-workbench.git graphdb-workbench-paths
cd graphdb-workbench-paths
git checkout <branch>
npm install
npm run start
```

--------------------------------

### Get All Connected GraphDB Locations

Source: https://graphdb.ontotext.com/documentation/11.1/admin-with-curl.html

List all GraphDB locations that the current instance is connected to. This helps in managing distributed GraphDB setups.

```bash
curl <base_url>/rest/locations
```

--------------------------------

### Run the example JAR

Source: https://graphdb.ontotext.com/documentation/11.1/helloworld.html

Execute the compiled Java application from the generated JAR file.

```bash
java -jar dev-examples-1.0-SNAPSHOT.jar

```

--------------------------------

### Java Hello World Example for GraphDB

Source: https://graphdb.ontotext.com/documentation/11.1/helloworld.html

Connects to a GraphDB repository, executes a SPARQL SELECT query, and prints the results. Ensure the GraphDB server is running and the repository exists.

```java
package com.ontotext.graphdb.example.app.hello;

import com.ontotext.graphdb.repository.http.GraphDBHTTPRepository;
import com.ontotext.graphdb.repository.http.GraphDBHTTPRepositoryBuilder;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.query.*;
import org.eclipse.rdf4j.repository.RepositoryConnection;

/**
 * Hello World app for GraphDB
 */
public class HelloWorld {
    public void hello() throws Exception {
        // Connect to a remote repository using the GraphDB client API
        // (ruleset is irrelevant for this example)
        GraphDBHTTPRepository repository = new GraphDBHTTPRepositoryBuilder()
                .withServerUrl("http://localhost:7200")
                .withRepositoryId("myrepo")
                //.withCluster(); // uncomment this line to enable cluster mode
                .build();

        // Alternative access to a remote repository using pure RDF4J
        // HTTPRepository repository = new HTTPRepository("http://localhost:7200/repositories/myrepo");

        // Separate connection to a repository
        RepositoryConnection connection = repository.getConnection();

        try {
            // Preparing a SELECT query for later evaluation
            TupleQuery tupleQuery = connection.prepareTupleQuery(QueryLanguage.SPARQL,
                    "SELECT ?x WHERE {" +
                            "BIND('Hello world!' as ?x)" +
                            "}");

            // Evaluating a prepared query returns an iterator-like object
            // that can be traversed with the methods hasNext() and next()
            TupleQueryResult tupleQueryResult = tupleQuery.evaluate();
            while (tupleQueryResult.hasNext()) {
                // Each result is represented by a BindingSet, which corresponds to a result row
                BindingSet bindingSet = tupleQueryResult.next();

                // Each BindingSet contains one or more Bindings
                for (Binding binding : bindingSet) {
                    // Each Binding contains the variable name and the value for this result row
                    String name = binding.getName();
                    Value value = binding.getValue();

                    System.out.println(name + " = " + value);
                }

                // Bindings can also be accessed explicitly by variable name
                //Binding binding = bindingSet.getBinding("x");
            }

            // Once we are done with a particular result we need to close it
            tupleQueryResult.close();

            // Doing more with the same connection object
            // ...
        } finally {
            // It is best to close the connection in a finally block
            connection.close();
        }
    }

    public static void main(String[] args) throws Exception {
        new HelloWorld().hello();
    }
}

```

--------------------------------

### Get Cluster Group Status with curl

Source: https://graphdb.ontotext.com/documentation/11.1/admin-with-curl.html

Check the status of the cluster group. This helps in monitoring the health of your distributed GraphDB setup.

```bash
curl -X GET --header 'Accept: application/json' '<base_url>/rest/cluster/group/status'
```

--------------------------------

### Setting External URL for Reverse Proxy

Source: https://graphdb.ontotext.com/documentation/11.1/directories-and-config-properties.html

When GraphDB is accessed via a reverse proxy with a root path other than '/', setting graphdb.external-url is recommended to ensure correct URL construction. This example shows a typical configuration for such a setup.

```properties
graphdb.external-url=http://rdf.example.com/
```

--------------------------------

### Start GraphDB Console

Source: https://graphdb.ontotext.com/documentation/11.1/command-line-tools.html

Launches the interactive GraphDB console. Use --help for a list of available options.

```bash
console --help
```

--------------------------------

### Basic entity filter example RDF data

Source: https://graphdb.ontotext.com/documentation/11.1/retrieval-graphdb-connector.html

This snippet defines the prefix and example URIs used in the basic entity filter example.

```turtle
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix example: <http://www.ontotext.com/example#> .
```

--------------------------------

### Start CloudWatch Agent with Configuration

Source: https://graphdb.ontotext.com/documentation/11.1/monitoring-aws.html

This command fetches the configuration from the specified JSON file and starts the CloudWatch agent on EC2 instances. Ensure the `config.json` file is in the correct location.

```bash
amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -s -c file:config.json

```

--------------------------------

### Initialize ExamplePlugin in GraphDB

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

This Java code demonstrates the initialization of a custom GraphDB plugin. It sets up IRIs and registers entities with the system scope during the plugin's initialization phase.

```java
public class ExamplePlugin extends PluginBase implements UpdateInterpreter, Preprocessor, Postprocessor {

    private static final String PREFIX = "http://example.com/";

    private static final String TIME_PREDICATE = PREFIX + "time";
    private static final String GO_FUTURE_PREDICATE = PREFIX + "goInFuture";
    private static final String GO_PAST_PREDICATE = PREFIX + "goInPast";

    private int timeOffsetHrs = 0;

    private IRI timeIri;

    // IDs of the entities in the entity pool
    private long timeID;
    private long goFutureID;
    private long goPastID;


    // Service interface methods
    @Override
    public String getName() {
        return "example";
    }

    // Plugin interface methods
    @Override
    public void initialize(InitReason reason, PluginConnection pluginConnection) {
        // Create IRIs to represent the entities
        timeIri = SimpleValueFactory.getInstance().createIRI(TIME_PREDICATE);
        IRI goFutureIRI = SimpleValueFactory.getInstance().createIRI(GO_FUTURE_PREDICATE);
        IRI goPastIRI = SimpleValueFactory.getInstance().createIRI(GO_PAST_PREDICATE);

        // Put the entities in the entity pool using the SYSTEM scope
        timeID = pluginConnection.getEntities().put(timeIri, Entities.Scope.SYSTEM);
        goFutureID = pluginConnection.getEntities().put(goFutureIRI, Entities.Scope.SYSTEM);
        goPastID = pluginConnection.getEntities().put(goPastIRI, Entities.Scope.SYSTEM);

        getLogger().info("Example plugin initialized!");
    }
}
```

--------------------------------

### SPARQL List Pattern Example 2

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

Example of a SPARQL query using a list pattern for the subject.

```sparql
SELECT * WHERE {
    (?s1, ?s2) <http://example.com/predicate> ?o
}

```

--------------------------------

### Start GraphDB with Custom Home Directory

Source: https://graphdb.ontotext.com/documentation/11.1/directories-and-config-properties.html

Use this command to start GraphDB and specify a custom directory for its home. This ensures all related data, configuration, and logs are stored in the chosen location.

```bash
graphdb -Dgraphdb.home=/opt/graphdb-instance
```

--------------------------------

### Full-Text Search Examples with Parameters

Source: https://graphdb.ontotext.com/documentation/11.1/full-text-search.html

These examples demonstrate various ways to call the `onto:fts` predicate with different combinations of query, index, and limit parameters. Note how language tags and RDF list construction affect the search.

```sparql
("query" "en" 10)
```

```sparql
("query" 15)
```

```sparql
("query"@de 20)
```

```sparql
("query"@de-CH 20)
```

```sparql
("query" "fr")
```

```sparql
"query"@fr
```

--------------------------------

### SPARQL List Pattern Example 1

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

Example of a SPARQL query using a list pattern for the object.

```sparql
SELECT * WHERE {
    ?s <http://example.com/predicate> (?o1 ?o2)
}

```

--------------------------------

### Datatype URL Example

Source: https://graphdb.ontotext.com/documentation/11.1/reasoning.html

Example showing how datatype URLs are written without brackets in GraphDB rulesets.

```N-Triples
a <owl:maxQualifiedCardinality> "1"^^xsd:nonNegativeInteger

```

--------------------------------

### Implement Query Preprocessing and Postprocessing

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

Implement Preprocessor and Postprocessor interfaces to inspect query requests, modify bindings, and control query results. This example demonstrates how to detect a specific FROM clause, create a custom binding set, and return it as the sole query result.

```java
public class ExamplePlugin extends PluginBase implements Preprocessor, Postprocessor {
    // ... initialize() and getName()

    // Preprocessor interface methods
    @Override
    public RequestContext preprocess(Request request) {
        // We are interested only in QueryRequests
        if (request instanceof QueryRequest) {
            QueryRequest queryRequest = (QueryRequest) request;
            Dataset dataset = queryRequest.getDataset();

            // Check if the predicate is included in the default graph. This means that we have a "FROM <our_predicate>"
            // clause in the SPARQL query.
            if ((dataset != null && dataset.getDefaultGraphs().contains(timeIri))) {
                // Create a date/time literal
                Value literal = createDateTimeLiteral();

                // Prepare a binding set with all projected variables set to the date/time literal value
                MapBindingSet result = new MapBindingSet();
                for (String bindingName : queryRequest.getTupleExpr().getBindingNames()) {
                    result.addBinding(bindingName, literal);
                }

                // Create a Context object which will be available during the other phases of the request processing
                // and set the created result as an attribute.
                RequestContextImpl context = new RequestContextImpl();
                context.setAttribute("bindings", result);

                return context;
            }
        }
        // If we are not interested in the request there is no need to create a Context.
        return null;
    }

    // Postprocessor interface methods
    @Override
    public boolean shouldPostprocess(RequestContext requestContext) {
        // Postprocess only if we have created RequestContext in the Preprocess phase. Here the requestContext object
        // is the same one that we created in the preprocess(...) method.
        return requestContext != null;
    }

    @Override
    public BindingSet postprocess(BindingSet bindingSet, RequestContext requestContext) {
        // Filter all results. Returning null will remove the binding set from the returned query result.
        // We will add the result we want in the flush() phase.
        return null;
    }

    @Override
    public Iterator<BindingSet> flush(RequestContext requestContext) {
        // Get the BindingSet we created in the Preprocess phase and return it.
        // This will be returned as the query result.
        BindingSet result = (BindingSet) ((RequestContextImpl) requestContext).getAttribute("bindings");
        return new SingletonIterator<>(result);
    }

    private Literal createDateTimeLiteral() {
        // Create a literal for the current timestamp.
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.HOUR, timeOffsetHrs);

        return SimpleValueFactory.getInstance().createLiteral(calendar.getTime());
    }
}
```

--------------------------------

### Example SPARQL Query

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

An example of a SPARQL query used in the context of pattern interpretation within the plugin lifecycle.

```sparql
SELECT * WHERE {
    ?s <http://example.com/predicate> ?o
}

```

--------------------------------

### Start GraphDB with External Plugins Directory

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

Use the `graphdb.extra.plugins` system property to specify a directory containing external plugins when starting GraphDB from the command line. This is useful for environments where restarting the database or persisting the `dist` folder is not feasible.

```bash
graphdb -Dgraphdb.extra.plugins=path/to/directory/with/external/plugins
```

--------------------------------

### Axioms Section Example

Source: https://graphdb.ontotext.com/documentation/11.1/reasoning.html

Example of an Axioms section in a GraphDB ruleset file, asserting RDF axiomatic triples.

```TTL
Axioms
{
    // RDF axiomatic triples
    <rdf:type>      <rdf:type> <rdf:Property>
    <rdf:subject>   <rdf:type> <rdf:Property>
    <rdf:predicate> <rdf:type> <rdf:Property>
    <rdf:object>    <rdf:type> <rdf:Property>
    <rdf:first>     <rdf:type> <rdf:Property>
    <rdf:rest>      <rdf:type> <rdf:Property>
    <rdf:value>     <rdf:type> <rdf:Property>
    <rdf:nil>       <rdf:type> <rdf:List>
}

```

--------------------------------

### ExamplePlugin Implementation

Source: https://graphdb.ontotext.com/documentation/11.1/plug-in-api.html

This Java code demonstrates how to implement the UpdateInterpreter, Preprocessor, and Postprocessor interfaces to create a custom plugin. It specifically handles time-related updates by listening for 'goFuture' and 'goPast' predicates.

```java
public class ExamplePlugin extends PluginBase implements UpdateInterpreter, Preprocessor, Postprocessor {
    // ... initialize() and getName()

    // ... Pre- and Postprocessor methods

    // UpdateInterpreter interface methods
    @Override
    public long[] getPredicatesToListenFor() {
        // We can filter the tuples we are interested in by their predicate. We are interested only
        // in tuples with have the predicate we are listening for.
        return new long[] {goFutureID, goPastID};
    }

    @Override
    public boolean interpretUpdate(long subject, long predicate, long object, long context, boolean isAddition,
                                   boolean isExplicit, PluginConnection pluginConnection) {
        // Make sure that the subject is the time entity
        if (subject == timeID) {
            final String intString = pluginConnection.getEntities().get(object).stringValue();
            int step;
            try {
                step = Integer.parseInt(intString);
            } catch (NumberFormatException e) {
                // Invalid input, propagate the error to the caller
                throw new ClientErrorException("Invalid integer value: " + intString);
            }

            if (predicate == goFutureID) {
                timeOffsetHrs += step;
            } else if (predicate == goPastID) {
                timeOffsetHrs -= step;
            }

            // We handled the statement.
            // Return true so the statement will not be interpreted by other plugins or inserted in the DB
            return true;
        }

        // Tell the PluginManager that we can not interpret the tuple so further processing can continue.
        return false;
    }
}
```
Tokens:
Raw