The RMLMapper execute RML rules to generate Linked Data. It is a Java library, which is available via the command line (API docs online). The RMLMapper loads all data in memory, so be aware when working with big datasets.

• Features
• Build
• Usage
  • CLI
  • Library
  • Docker
  • Including functions
• Testing
• Dependencies
• Remarks
• Documentation
  • UML Diagrams

• local data sources:
• CSV files (including CSVW)
• JSON files (JSONPath)
• XML files (XPath)
• remote data sources:
• relational databases (MySQL, PostgreSQL, and SQLServer)
• SPARQL endpoints
• files via HTTP urls (via GET)
• CSV files
• JSON files (JSONPath)
• XML files (XPath)
• functions (most cases)
• configuration file
• metadata generation
• output formats: nquads (default), turtle, trig, trix, jsonld, hdt
• join conditions

• functions (all cases)
• conditions (all cases)
• data sources:
  • NoSQL databases
  • web APIs
  • TPF servers

The RMLMapper is build using Maven: mvn install. A standalone jar can be found in /target.

The following options are most common.

• -m, --mapping <arg>: one or more mapping file paths and/or strings (multiple values are concatenated).
• -o, --output <arg>: path to output file
• -s,--serialization <arg>: serialization format (nquads (default), trig, trix, jsonld, hdt)

All options can be found when executing java -jar rmlmapper.jar --help, that output is found below.

usage: java -jar mapper.jar <options>
options:
 -c,--configfile <arg>            path to configuration file
 -d,--duplicates                  remove duplicates in the output
 -dsn,--r2rml-jdbcDriver <arg>    DSN of the database when using R2RML rules
 -e,--metadatafile <arg>          path to output metadata file
 -f,--functionfile <arg>          path to functions.ttl file (dynamic
                                  functions are found relative to
                                  functions.ttl)
 -h,--help                        show help info
 -l,--metadataDetailLevel <arg>   generate metadata on given detail level
                                  (dataset - triple - term)
 -m,--mappingfile <arg>           one or more mapping file paths and/or
                                  strings (multiple values are
                                  concatenated). r2rml is converted to rml 
                                  if needed using the r2rml arguments.
 -o,--outputfile <arg>            path to output file (default: stdout)
 -p,--r2rml-password <arg>        password of the database when using R2RML rules
 -s,--serialization <arg>         serialization format (nquads (default),
                                  turtle, trig, trix, jsonld, hdt)
 -t,--triplesmaps <arg>           IRIs of the triplesmaps that should be
                                  executed in order, split by ',' (default
                                  is all triplesmaps)
 -u,--r2rml-username <arg>        username of the database when using R2RML rules
 -v,--verbose                     show more details in debugging output

An example of how you can use the RMLMapper as an external library can be found at ./src/test/java/be/ugent/rml/readme/ReadmeTest.java

You can use Docker to run the RMLMapper by following these steps:

• Build the Docker image: docker build -t rmlmapper ..
• Run a Docker container: docker run --rm -v $(pwd):/data rmlmapper -m mapping.ttl.

The same parameters are available as via the CLI. The RMLMapper is executed in the /data folder in the Docker container.

There are two ways to include (new) functions within the RML Mapper

• dynamic loading: you add links to java files or jar files, and those files are loaded dynamically at runtime
• preloading: you register functionality via code, and you need to rebuild the mapper to use that functionality

Registration of functions is done using a Turtle file, which you can find in src/main/resources/functions.ttl

The snippet below for example links an fno:function to a library, provided by a jar-file (GrelFunctions.jar).

grel:toUpperCase a fno:Function ;
  fno:name "to Uppercase" ;
  rdfs:label "to Uppercase" ;
  dcterms:description "Returns the input with all letters in upper case." ;
  fno:expects ( grel:valueParam ) ;
  fno:returns ( grel:stringOut ) ;
  lib:providedBy [
    lib:localLibrary "GrelFunctions.jar";
    lib:class "GrelFunctions";
    lib:method "toUppercase"
  ].

Just put the java or jar-file in the resources folder, at the root folder of the jar-location, or the parent folder of the jar-location, it will be found dynamically.

Note: the java or jar-files are found relative to the loaded functions.ttl. You can change the functions.ttl path using a commandline-option (-f).

This overrides the dynamic loading. An example of how you can use Preload a custom function can be found at ./src/test/java/be/ugent/rml/readme/ReadmeFunctionTest.java

Make sure you have Docker running.

• A problem with Docker (can't start the container) causes the SQLServer tests to fail locally. These tests will always succeed locally.
• A problem with Docker (can't start the container) causes the PostgreSQL tests to fail locally on Windows 7 machines.

The RMLMapper's XML parsing implementation (javax.xml.parsers) has been chosen to support full XPath. This implementation causes a large memory consumption (up to ten times larger than the original XML file size). However, the RMLMapper can be easily adapted to use a different XML parsing implementation that might be better suited for a specific use case.

The processor checks whether correct language tags are not, using a regular expression. The regex has no support for languages of length 5-8, but this currently only applies to 'qaa..qtz'.

Generate static files at /docs/apidocs with:

mvn javadoc:javadoc

(Requires Ultimate edition)

• Right click on package: "be.ugent.rml"
• Diagrams > Show Diagram > Java Class Diagrams
• Choose what properties of the classes you want to show in the upper left corner
• Export to file > .png | Save diagram > .uml

• Go to draw.io
• Click on 'Open Existing Diagram' and choose the .html file