Many initiatives have emerged to aid one in publishing structured resources as Linked Data on the Web with one of the major achievements being the R2RML W3C Recommendation. R2RML and its dialects assume a certain underlying technology (e.g., Core SQL 2008). This means that domain-specific data transformations - such as transforming geospatial coordinates - rely either on that underlying technology or data-preprocessing steps. We argue that one can incorporate and subsequently share that procedural domain knowledge in such mappings. Such an extension would make certain pre-processing steps redundant. One can furthermore attach metadata to these functions, which can be published as well. In this paper, we present R2RML-F, an extension to R2RML, that adopts ECMAScript for capturing domain knowledge and for which we have developed a prototype. We demonstrate the viability of the approach with a demonstration and compare its performance with different mappings in some initial experiments. Our preliminary results suggest that there is little or no overhead with respect to relying on underlying technology.
Fifteen years ago, Tim Berners-Lee wrote a Design Issue [
According to [
Ensure a minimal extension of R2RML that reuses as much as possible existing predicates; Adopt a standardized programming language to represent procedural domain knowledge for which multiple implementations exist.
The result of taking this approach is R2RML-F, where the ‘F’ stands for “function”. R2RML-F adopts ECMAScript1 as the programming language and we have extended the R2RML vocabulary to include notions for function calls and parameter bindings. Next to these contributions, this paper presents details of the prototype and examples demonstrating the viability of the approach. The remainder of this paper is organized as follows: Section 2 presents R2RML-F; Section 3 provides some details on the implementation of the prototype; Section 4 is used to demonstrate the ideas as well as to present experiments to evaluate the performance of R2RML-F; Section 5 presents related work; and Section 6 concludes the paper.
In this section we describe the predicates introduced and our extension of R2RML. We do assume the reader is familiar with R2RML and will introduce the notions of the approach through a simple example. In Listing 1 we declare a function that multiplies 1 JavaScript is a popular implementation of ECMAScript. Implementations of ECMAScript often extend the language or provide APIs. One example is JavaScript providing APIs to interact with a Web browser. two arguments2: <#Multiply> rrf:functionName "multiply" ; rrf:functionBody """ function multiply(var1, var2) { return var1 * var2 ; Each function is a resource that must have two relationships: a function name (a literal) and a function body (also a literal); the function name and name of the function in the function body must be identical. Each R2RML-F mapping cannot have two functions with the same name and each function must have exactly one function name and exactly one function body. Any errors will be reported to the user.
Listing 2 demonstrates how functions are called from within a Predicate Object Map. We have introduced the new term map function call. A term map must now be exactly one of the following: a constant-valued term map, a column-valued term map, a template-valued term map or a function-call-valued term map. A function call: • • must refer to exactly one function; and must have at most one list of parameter bindings.
When no list of parameter bindings or an empty list is provided,
they are considered to be function calls where no parameters are
being passed. The order of the parameters that are passed is
important. Adopting the RDF Sequence container was not an option,
as RDF does not provide a mechanism to state a container has no
more members [
An existing R2RML processor, called db2triples, was extended. The extension is available as a branch on GitHub.3 Prior to processing the mappings, the R2RML-F processor first looks for and evaluates the functions using Java’s Nashorn4 JavaScript engine. Any problems with the function results in an error that will be sent back to the user.
Function calls are implemented as term maps and each function call has a list of term-maps that constitute its arguments. Each argument is evaluated before the results are passed on to the function being called. This can be compared to the greedy evaluation strategy found in some programming languages. Any runtime errors halt the process and the user is made aware of where the problem resides.
We currently support no monitoring of the functions and rely on Nashorn and the Java Runtime Environment to handle issues concerning memory management and the correctness of code (e.g., infinite loops). 4. DEMONSTRATION AND EXPERIMENT We demonstrate and evaluate our approach with a use case provided by the Ordnance Survey Ireland (OSi)5. The OSi is Ireland’s national mapping agency and the geometries in their system are represented using the Irish Transverse Mercator (ITM)6 coordinate system. At an international level, however, World Geodetic System 84 (or WSG 84)7 is the standard used in cartography and navigation (amongst others). Transforming coordinates from one coordinate system to another is a common task for which (integrated) tools exist, but not all relational databases support those. For the demonstration and experiment, we created a table representing the 26 counties of The Republic of Ireland (see Table 1), with the following fields: “id” – an identifier stored as an integer; “name” – the name of the county as a varchar; “geom” – a point of that county as a geometry object (internal representation omitted for this paper); and “geoms” – capturing that same point as a varchar in WKT format.8 The table is stored in a PostgreSQL database supporting geometries with PostGIS. The purpose of this table is to demonstrate the transformation of the textual representation of points with our approach and compare it with a mapping using PostGIS’ functionality. 2 http://kdeg.scss.tcd.ie/ns/rrf# is the namespace URI for the
R2RML-F predicates and is prefixed with “rrf” in this paper. 3 Available at https://github.com/CNGL-repo/db2triples 4 https://blogs.oracle.com/nashorn/ 5 http://www.osi.ie/ 6 https://en.wikipedia.org/wiki/Irish_Transverse_Mercator 7 https://en.wikipedia.org/wiki/World_Geodetic_System 8 https://en.wikipedia.org/wiki/Well-known_text Simulating a relational database that does not support geometries, we have created a mapping M1 that maps “id”, “name” and “geoms” to triples. This mapping is shown in Listing 3, but the function – which takes a fair amount of space and therefore omitted – is based on a PHP script9 that has been ported to ECMAScript. One can see that the mapping should result in two RDF triples for each record. <#TriplesMap1> rr:logicalTable [ rr:sqlQuery "SELECT id, name, geoms FROM county" ; ] ; rr:subjectMap [ rr:template "http://data.example.com/county/{id}" ; ] ; rr:predicateObjectMap [ rr:predicate ex:name ; rr:termType rr:Literal; rr:objectMap [ rr:column "name" ]; ] ; rr:predicateObjectMap [ rr:predicate ex:point ; rr:objectMap [ rr:termType rr:Literal; rrf:functionCall [ rrf:function <#Transform> ; rrf:parameterBindings ( [ rr:column "geoms" ] ) ; ] ; ] ; ] ; The execution of our processor generated 52 triples of which some are shown in Figure 1. We will now proceed with evaluating our approach with other mappings in order to analyze the impact of incorporating domain knowledge in the mapping.
Before describing the experiment, we note that our experiment 9 The function to transform ITM into WGS84 is based on http://www.nearby.org.uk/blog/2009/05/13/itm-wgs84-andirish-grid-and-british-national-grid-php-code/ was run on a MacBook Pro 12.1 with an Intel Core i5 processor (2.7 GHz) and a memory of 8 GB (1867 MHz DDR3). The IDE used is the Eclipse IDE Mars Release (4.5.0) and the Java version 1.8.0_45.
To compare the performance of our approach, we have created two additional mappings. The mappings we will compare are: • • •
M1 (Listing 3) mapping a text field containing points which are transformed via a function; M2 (Listing 4) casting the geometry into a string and providing that field as input to the function; and M3 (Listing 5) transforming the geometry into WGS84 in the SQL query, therefore not relying on the function provided in the mapping.
M2 was created to analyze the impact of casting geometries to strings.
For each mapping we have run a script that executes a mapping 110 times in the same virtual machine and measures the execution times. The script was thus run three times, once for each mapping. For each mapping, we ignore the first ten measurements to avoid a bias created by cold starting the Java Virtual Machine. Even though M3 does not use a function, we have not removed the function from the mapping. As functions are loaded only once (prior to executing the mappings), this creates a constant across the three mappings allowing us to more reliably compare the execution times measured. The results are shown in Table 2. Looking at the average runtime, it is surprising to see that our approach in M1 seemingly performs better than a mapping with no function calls. In order to investigate whether the differences are significant, we performed a Welch Two Sample T-Test for each pair of mappings M1-M2, M1-M3 and M1-M2. The significance level we adopt is 0.05. The p-values for each test are: 1. 2. 3.
M1-M2: 0.8518 > 0.05 M1-M3: 0.06564 > 0.05
M2-M3: 0.0838 > 0.05 All p-values are above 0.05, which suggests that the differences are not significant. This also suggests – at the moment – that our approach, viable from a technical point of view, seems not to cause any serious overhead for this particular use case. We notice that the last two p-values – comparing a mapping applying the function with a mapping that does not – are closer to the confidence level than the first. M1 and M2 rely on calling the function and their difference seems not significant.
We recognize the size of the dataset is limited and the function
very complex, so we have ran additional experiments with a larger
dataset and a simple function that are similar in setup. We created
a table with two columns (“id”, “x” and “y” – all integers) and
generated 1,000 records with random values between 0 and 100
for x and y. The first experiment mapped the multiplication of x
with x, the second the multiplication of x and y. The main
difference is the number of parameters (one vs. two), with the first
being more similar to the conversion of coordinates (i.e., only one
argument is passed).
create richer mappings, but limited to XML documents. The same
holds for RML [
We have to note that functions in transformations have been
studied in different domains, such as model-to-model transformations,
for which specifications have been developed. One noteworthy
example of such a specification in that domain is
Query/View/Transformation (QVT) defined by the Object
Management Group allowing one access to operators, constructs and
functions to transform UML into, for instance, ER [
XSPARQL [
On representing functions. SPIN [
On R2RML extensions. RML [
Future work includes additional experiments to validate our findings and developing additional scenarios and use cases to motivate the need for incorporating functions in a mapping, e.g., those calling web services.
This study is supported by the Science Foundation Ireland (Grant 13/RC/2106) as part of the ADAPT Centre for Digital Content Platform Research (http://www.adaptcentre.ie/) at Trinity College Dublin. We thank the Ordnance Survey Ireland (OSi) for permitting us to use their boundaries dataset for the purposes of this research project. Within OSi, we are especially grateful for the input and domain expertise provided by Lorraine McNerney and Éamonn Clinton. 11 https://jena.apache.org/
Here we provide listings referred to in the text. <#TriplesMap1> rr:logicalTable [ rr:sqlQuery """SELECT id, name, ST_AsText(geom)
AS geom FROM boundaries.county""" ; ] ; rr:subjectMap [ rr:template "http://data.example.com/county/{id}" ; ] ; rr:predicateObjectMap [ rr:predicate ex:name ; rr:termType rr:Literal; rr:objectMap [ rr:column "name" ]; ] ; rr:predicateObjectMap [ rr:predicate ex:point ; rr:objectMap [ rr:termType rr:Literal; rrf:functionCall [ rrf:function <#Transform> ; rrf:parameterBindings ( [ rr:column "geom" ] ) ; ] ; ] ; ] ; .
Listing 4: An R2RML-F mapping transforming points from a geometry cast to a string with a function captured in the mapping (mapping M2). Differences wrt Listing 3 are highlighted. <#TriplesMap1> rr:logicalTable [ rr:sqlQuery """SELECT id, name,
ST_AsText(ST_Transform(geom,4326))
AS geom FROM boundaries.county""" ;