2. RDFox Features and Requirements¶

2.1. RDFox Features¶

RDFox provides the following main functionality:

RDFox can import RDF triples, rules, and OWL 2 and SWRL axioms either programmatically or from files of certain formats (see Section 3 for a quick introduction). Additionally, RDFox can import information from external data sources, such as csv files or relational databases (see Section 6).
Triples, rules and axioms can be exported into a number of different formats. Furthermore, the contents of the system can be incrementally saved into a binary file, which can later be loaded to restore the system’s state.
RDFox supports ACID transactional updates (see Section 7 for further details on transactions).
Individual information elements in the system can be assigned different access permissions for different users (see Section 9 for further details on access control).
RDFox can answer SPARQL 1.1 queries (see Section 4) and provides functionality for monitoring query answering and accessing query plans.
RDFox supports materialization-based reasoning, where all triples that logically follow from the facts and rules in the system are materialized as new triples (see Section 5) . Materializations can be incrementally updated, which means that reasoning does not need to be performed from scratch once the information in the system is updated. Furthermore, the results of reasoning can be explained, which means that RDFox is able to return proofs for any new fact added to the store through materialization.

2.2. Available Modes¶

The core of RDFox is written in C++, but a number of APIs have been developed in order to enable integration of RDFox with applications written in other programming languages. In general, RDFox is accessible in the following ways.

RDFox can be accessed as a native library from Java.
RDFox also has a command-line user interface that supports a list of useful commands.
RDFox can be used in a server mode, providing access via a RESTful API.

2.3. Software Archive¶

Each software archive contains a prebuilt OS specific version of RDFox as a library and as an executable. The archive also contains the Java API for easy integration of RDFox with programs written in Java. We next describe in detail the files and directories inside the archive.

The “lib” directory contains the libraries.
- JRDFox.jar is the Java bridge to the native RDFox engine.
- libRDFox.dylib (on macOS), libRDFox.so (on Linux), and RDFox.dll (on Windows) contain the native RDFox engine required by JRDFox.jar.
- RDFox (on macOS and Linux) and RDFox.exe (on Windows) are stand-alone executables that can be used to run RDFox on the command line and start the RESTful API endpoint.
The “examples” directory contains demonstration programs that show how to call RDFox as a library from Java. The “examples/Java/build.xml” Apache Ant script can be used to compile and run the Java demonstration program.
The “javadoc” directory contains the Javadoc documentation for JRDFox.

To use JRDFox in a project, simply add JRDFox.jar to your classpath, and make sure that the path to the dynamic library (libRDFox.dylib on macOS, libRDFox.so on Linux, and RDFox.dll on Windows) is correctly specified when starting your program using the following JVM option.

-Djava.library.path=<path to the dynamic library>

2.4. System Requirements¶

2.4.1. Operating Systems¶

RDFox supports the following operating system versions

Windows

Windows 8 or higher

Mac

macOS 10.14 or higher

Linux

Centos 7 or higher
Ubuntu 16.04 or higher
Fedora 27 or higher

Additionally, RDFox can be run using Docker. See Section 11 for details.

2.4.2. Hardware¶

RDFox is a main-memory data store and as such its performance is heavily dependent on access to a suitable amount of RAM. Oxford Semantic Technologies recommends that users ensure that RDFox has unpaged access to between 60 and 110 bytes of RAM per triple that their store will contain. This includes both explicitly imported triples and those materialized via reasoning.

2.4.3. License¶

Running the RDFox executable, or any application which uses the JRDFox API, requires a license key issued by Oxford Semantic Technologies. In all cases, installing an authentic, in-date license key file as $HOME/.RDFox/RDFox.lic on Linux/Max, or %LOCALAPPDATA%\RDFox\RDFox.lic on Windows, will allow the core of RDFox to run. Where this is impractical, the license can also be provided in one of the following ways, all of which take precedence over any file installed in the fixed locations described above:

(RDFox executable only) - by adding the RDFox.lic file to the directory containing the RDFox executable, taking care to preserve the file name.
(RDFox executable only) - by supplying the license-file or the license-content server parameter on the command line.
(JRDFox applications only) - by supplying the full path of the license file as a server parameter with key license-file when calling tech.oxfordsemantic.jrdfox.client.ConnectionFactory.startLocalServer(...). For example:
```
Map<String, String> serverParams = new HashMap<>();
serverParams.put("license-file", "/home/user/rdfox.lic");
ConnectionFactory.startLocalServer(serverParams);
```

(JRDFox applications only) - by supplying the contents of the license file as a server parameter with key license-content when calling tech.oxfordsemantic.jrdfox.client.ConnectionFactory.startLocalServer(...). For example:

Map<String, String> serverParams = new HashMap<>();
serverParams.put("license-content", "expiryTime:1588350051\n" +
        "licenseType:Developer\n" +
        "licenseeEmail:auser@organization.com\n" +
        "licenseeName:A User\n" +
        "organisation:Organisation\n" +
        "signature:XXXXXX");
ConnectionFactory.startLocalServer(serverParams);

Note that, unless the license is installed at the user-specific location specified above, calls to tech.oxfordsemantic.jrdfox.client.ConnectionFactory.newServerConnection(...) will fail unless the license has already been provided via a server parameter.