=Paper=
{{Paper
|id=Vol-1593/article-13
|storemode=property
|title=None
|pdfUrl=https://ceur-ws.org/Vol-1593/article-13.pdf
|volume=Vol-1593
|dblpUrl=https://dblp.org/rec/conf/www/DebruyneO16
}}
==None==
https://ceur-ws.org/Vol-1593/article-13.pdf
R2RML-F: Towards Sharing and Executing Domain Logic
in R2RML Mappings
Christophe Debruyne Declan O’Sullivan
Trinity College Dublin Trinity College Dublin
Dublin 2, Ireland Dublin 2, Ireland
debruync@scss.tcd.ie declan.osullivan@scss.tcd.ie
ABSTRACT could include construct to support the declaration of user-defined
Many initiatives have emerged to aid one in publishing structured functions (amongst others).
resources as Linked Data on the Web with one of the major There are cases where the underlying database does not support
achievements being the R2RML W3C Recommendation. R2RML certain data manipulations because they are not expressive enough
and its dialects assume a certain underlying technology (e.g., Core or because procedural domain knowledge is part of the application
SQL 2008). This means that domain-specific data transformations layer rather than the database layer. Converting units might be a
– such as transforming geospatial coordinates – rely either on that straightforward conversion that one can formulate in a SQL query,
underlying technology or data-preprocessing steps. We argue that but others are more complex and people have to resort to more
one can incorporate and subsequently share that procedural do- complex data processing “pipelines”; preprocessing the data and
main knowledge in such mappings. Such an extension would transforming the result into RDF or transform the data into an
make certain pre-processing steps redundant. One can furthermore RDF graph and manipulate the RDF graph to create a new RDF
attach metadata to these functions, which can be published as graph. Kovalenko et al. investigated the latter in [10] and they
well. In this paper, we present R2RML-F, an extension to observed that some techniques (e.g., SPIN [11]) support user-
R2RML, that adopts ECMAScript for capturing domain defined functions. Both approaches are, however, still conducted
knowledge and for which we have developed a prototype. We in two steps and that renders the whole process more complex
demonstrate the viability of the approach with a demonstration then it should be.
and compare its performance with different mappings in some
We, however, feel that such procedural knowledge can and should
initial experiments. Our preliminary results suggest that there is
be included in the mapping. Moreover, by incorporating that
little or no overhead with respect to relying on underlying tech-
knowledge in the mapping, one can also share the procedural
nology.
knowledge and events described, as well as annotate with metada-
CCS Concepts ta (e.g., with predicates from PROV-O [12]). The requirements
we state for our approach are:
H.4 [Information Systems Applications]: Miscellaneous; H.5 1. Ensure a minimal extension of R2RML that reuses as
[World Wide Web]: Web data description languages. much as possible existing predicates;
2. Adopt a standardized programming language to repre-
Keywords sent procedural domain knowledge for which multiple
R2RML; Linked Data; Mapping. implementations exist.
1. INTRODUCTION The result of taking this approach is R2RML-F, where the ‘F’
Fifteen years ago, Tim Berners-Lee wrote a Design Issue [2] sug- stands for “function”. R2RML-F adopts ECMAScript1 as the pro-
gesting how to publish the information contained in relational gramming language and we have extended the R2RML vocabu-
databases on the Semantic Web. Many tools have emerged (see lary to include notions for function calls and parameter bindings.
[15] for a survey) to generate RDF from these databases either via Next to these contributions, this paper presents details of the pro-
direct mappings – based on the ideas outlined in [2] with the RDF totype and examples demonstrating the viability of the approach.
reflecting the database’s structure and labels – or via annotations The remainder of this paper is organized as follows: Section 2
where tables, views and queries are related to concepts and rela- presents R2RML-F; Section 3 provides some details on the im-
tions in ontologies to create a knowledge base. Both approaches plementation of the prototype; Section 4 is used to demonstrate
ultimately led to two W3C Recommendations; a direct mapping the ideas as well as to present experiments to evaluate the perfor-
of relational data to RDF [1] and R2RML [6]. The R2RML speci- mance of R2RML-F; Section 5 presents related work; and Section
fication assumes that the relational database is annotated to con- 6 concludes the paper.
form to the Core SQL 2008 specification.
According to [3], a model management system is “a component
2. EXTENDING R2RML
that supports the creation, compilation, reuse, evolution, and exe- In this section we describe the predicates introduced and our ex-
cution of mappings between schemas represented in a wide range tension of R2RML. We do assume the reader is familiar with
of metamodels.” They also argued that mapping languages should R2RML and will introduce the notions of the approach through a
be more expressive if one wants to support various use case sce- simple example. In Listing 1 we declare a function that multiplies
narios and that – provided that tractability is not a problem – one
1
JavaScript is a popular implementation of ECMAScript. Imple-
mentations of ECMAScript often extend the language or pro-
Copyright is held by the author/owner(s). vide APIs. One example is JavaScript providing APIs to interact
WWW2016 Workshop: Linked Data on the Web (LDOW2016) with a Web browser.
two arguments2: Any problems with the function results in an error that will be sent
<#Multiply> back to the user.
rrf:functionName "multiply" ;
rrf:functionBody """ Function calls are implemented as term maps and each function
function multiply(var1, var2) { call has a list of term-maps that constitute its arguments. Each
return var1 * var2 ; argument is evaluated before the results are passed on to the func-
}
""" ;
tion being called. This can be compared to the greedy evaluation
. strategy found in some programming languages. Any runtime
Listing 1: Declaring a function in R2RML-F errors halt the process and the user is made aware of where the
problem resides.
Each function is a resource that must have two relationships: a
function name (a literal) and a function body (also a literal); the We currently support no monitoring of the functions and rely on
function name and name of the function in the function body must Nashorn and the Java Runtime Environment to handle issues con-
be identical. Each R2RML-F mapping cannot have two functions cerning memory management and the correctness of code (e.g.,
with the same name and each function must have exactly one infinite loops).
function name and exactly one function body. Any errors will be 4. DEMONSTRATION AND EXPERIMENT
reported to the user.
We demonstrate and evaluate our approach with a use case pro-
Listing 2 demonstrates how functions are called from within a vided by the Ordnance Survey Ireland (OSi)5. The OSi is Ireland’s
Predicate Object Map. We have introduced the new term map national mapping agency and the geometries in their system are
function call. A term map must now be exactly one of the follow- represented using the Irish Transverse Mercator (ITM)6 coordi-
ing: a constant-valued term map, a column-valued term map, a nate system. At an international level, however, World Geodetic
template-valued term map or a function-call-valued term map. A System 84 (or WSG 84)7 is the standard used in cartography and
function call: navigation (amongst others). Transforming coordinates from one
• must refer to exactly one function; and coordinate system to another is a common task for which (inte-
• must have at most one list of parameter bindings. grated) tools exist, but not all relational databases support those.
When no list of parameter bindings or an empty list is provided, For the demonstration and experiment, we created a table repre-
they are considered to be function calls where no parameters are senting the 26 counties of The Republic of Ireland (see Table 1),
being passed. The order of the parameters that are passed is im- with the following fields: “id” – an identifier stored as an integer;
portant. Adopting the RDF Sequence container was not an option, “name” – the name of the county as a varchar; “geom” – a point
as RDF does not provide a mechanism to state a container has no of that county as a geometry object (internal representation omit-
more members [5]. The RDF Collection vocabulary of classes and ted for this paper); and “geoms” – capturing that same point as a
properties can describe a closed collection as a list [5]. RDF Col- varchar in WKT format.8 The table is stored in a PostgreSQL
lections are therefore suitable for passing arguments. The ele- database supporting geometries with PostGIS. The purpose of this
ments in this list – if any – must be term maps. Functions calls can table is to demonstrate the transformation of the textual represen-
thus be passed the results of columns, constants, templates or tation of points with our approach and compare it with a mapping
another function call. using PostGIS’ functionality.
<#TriplesMap1> Table 1: The table “county” in the “boundaries” database
rr:logicalTable [ rr:tableName "Employee"; ];
rr:subjectMap [
id name geom geoms
rr:template "http://org.com/employee/{ID}"; 10000 CARLOW POINT(671989.126 676051.233)
] ; 20000 CAVAN POINT(649270.487 796627.36)
rr:predicateObjectMap [ 30000 CLARE POINT(532617.573 676288.529)
rr:predicate ex:salary ; 40000 CORK POINT(159956.935 79499.879)
rr:objectMap [
rr:datatype xsd:double ; 50000 DONEGAL POINT(599999.588 907696.186)
rrf:functionCall [ 60000 GALWAY POINT(533393.941 731920.418)
rrf:function <#Multiply> ; 70000 KERRY POINT(480286.589 603093.557)
rrf:parameterBindings ( 80000 KILDARE POINT(683580.721 713638.655)
[ rr:constant "12"^^xsd:integer ]
90000 KILKENNY POINT(650826.971 648269.702)
[ rr:column "monthly_salary" ]
) ; 100000 LAOIS POINT(640275.125 640275.125)
] ; 110000 LEITRIM POINT(600000.431 818660.17)
] ; 120000 LIMERICK POINT(549077.109 638997.81)
] ; 130000 LONGFORD POINT(616521.486 768575.569)
.
140000 LOUTH POINT(698735.035 788136.627)
Listing 2: Using function in a Predicate Object Map 150000 MAYO POINT(517850.357 795236.186)
3. IMPLEMENTATION 160000 MEATH POINT(688113.609 769372.026)
170000 MONAGHAN POINT(662572.109 833219.834)
An existing R2RML processor, called db2triples, was extended.
180000 OFFALY POINT(633368.373 722298.005)
The extension is available as a branch on GitHub.3 Prior to pro- 190000 ROSCOMMON POINT(183556.633 277830.739)
cessing the mappings, the R2RML-F processor first looks for and 200000 SLIGO POINT(556553.63 833667.473)
evaluates the functions using Java’s Nashorn4 JavaScript engine. 210000 TIPPERARY POINT(611273.837 657290.162)
2 5
http://kdeg.scss.tcd.ie/ns/rrf# is the namespace URI for the http://www.osi.ie/
6
R2RML-F predicates and is prefixed with “rrf” in this paper. https://en.wikipedia.org/wiki/Irish_Transverse_Mercator
3 7
Available at https://github.com/CNGL-repo/db2triples https://en.wikipedia.org/wiki/World_Geodetic_System
4 8
https://blogs.oracle.com/nashorn/ https://en.wikipedia.org/wiki/Well-known_text
220000 WATERFORD POINT(634140.854 611037.497) was run on a MacBook Pro 12.1 with an Intel Core i5 processor
230000 WESTMEATH POINT(633172.984 750116.57) (2.7 GHz) and a memory of 8 GB (1867 MHz DDR3). The IDE
240000 WEXFORD POINT(684871.008 639468.666) used is the Eclipse IDE Mars Release (4.5.0) and the Java version
250000 WICKLOW POINT(706277.46 695537.898) 1.8.0_45.
260000 DUBLIN POINT(716330.154 742154.083)
To compare the performance of our approach, we have created
two additional mappings. The mappings we will compare are:
Simulating a relational database that does not support geometries,
we have created a mapping M1 that maps “id”, “name” and “ge- • M1 (Listing 3) mapping a text field containing points
oms” to triples. This mapping is shown in Listing 3, but the func- which are transformed via a function;
tion – which takes a fair amount of space and therefore omitted – • M2 (Listing 4) casting the geometry into a string and
is based on a PHP script9 that has been ported to ECMAScript. providing that field as input to the function; and
One can see that the mapping should result in two RDF triples for • M3 (Listing 5) transforming the geometry into WGS84
each record. in the SQL query, therefore not relying on the function
<#TriplesMap1>
provided in the mapping.
rr:logicalTable [ M2 was created to analyze the impact of casting geometries to
rr:sqlQuery "SELECT id, name, geoms FROM county" ;
] ; strings.
rr:subjectMap [
rr:template "http://data.example.com/county/{id}" ;
For each mapping we have run a script that executes a mapping
] ; 110 times in the same virtual machine and measures the execution
rr:predicateObjectMap [ times. The script was thus run three times, once for each mapping.
rr:predicate ex:name ; For each mapping, we ignore the first ten measurements to avoid a
rr:termType rr:Literal;
rr:objectMap [ rr:column "name" ]; bias created by cold starting the Java Virtual Machine. Even
] ; though M3 does not use a function, we have not removed the
rr:predicateObjectMap [ function from the mapping. As functions are loaded only once
rr:predicate ex:point ;
rr:objectMap [ (prior to executing the mappings), this creates a constant across
rr:termType rr:Literal; the three mappings allowing us to more reliably compare the exe-
rrf:functionCall [ cution times measured. The results are shown in Table 2.
rrf:function <#Transform> ;
rrf:parameterBindings ( Table 2: Average, maximum and minimum execution time in
[ rr:column "geoms" ] milliseconds for 100 runs with each mapping.
) ;
] ; M1 M2 M3
] ;
] ; Average 77.66 78.62 87.86
. Standard Deviation 37.69 34.80 40.19
<#Transform> Min out of 100 runs 16.00 20.00 15.00
rrf:functionName "transform" ;
rrf:functionBody """ Max out of 100 runs 205.00 214.00 205.00
// Omitted
""" ;
. Looking at the average runtime, it is surprising to see that our
Listing 3: An R2RML-F mapping transforming points in a approach in M1 seemingly performs better than a mapping with
text field with a function in the mapping (mapping M1). no function calls. In order to investigate whether the differences
are significant, we performed a Welch Two Sample T-Test for
The execution of our processor generated 52 triples of which
each pair of mappings M1-M2, M1-M3 and M1-M2. The signifi-
some are shown in Figure 1. We will now proceed with evaluating cance level we adopt is 0.05. The p-values for each test are:
our approach with other mappings in order to analyze the impact
of incorporating domain knowledge in the mapping. 1. M1-M2: 0.8518 > 0.05
2. M1-M3: 0.06564 > 0.05
3. 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 confi-
dence level than the first. M1 and M2 rely on calling the function
and their difference seems not significant.
4.1 Additional Experiments
We recognize the size of the dataset is limited and the function
Figure 1: Partial result of the transformation. very complex, so we have ran additional experiments with a larger
dataset and a simple function that are similar in setup. We created
Before describing the experiment, we note that our experiment a table with two columns (“id”, “x” and “y” – all integers) and
generated 1,000 records with random values between 0 and 100
9
for x and y. The first experiment mapped the multiplication of x
The function to transform ITM into WGS84 is based on with x, the second the multiplication of x and y. The main differ-
http://www.nearby.org.uk/blog/2009/05/13/itm-wgs84-and- ence is the number of parameters (one vs. two), with the first be-
irish-grid-and-british-national-grid-php-code/
ing more similar to the conversion of coordinates (i.e., only one create richer mappings, but limited to XML documents. The same
argument is passed). holds for RML [8] when mapping XML documents to RDF.
Two mappings were created for the first experiment: one applying On representing functions. SPIN [11] provides concepts and
a function that multiplies x with x, and one where that multiplica- predicates for describing functions that we have decided not to
tion is part of the SQL query.10 Again executing each mapping reuse. One of the important differences is that SPIN proposes the
110 times in the same process and only taking the last 100 times use of predicates sp:arg1, …, sp:argn for binding the pa-
into account, we now notice that the p-value is 0.00541 indicating rameters. We consider the use RDF Collections more elegant. As
that there is strong evidence against the two mappings being [10] noted, Apache Jena11 allows one to integrate functions by
equal, with M1 performing better. Similarly, two mappings were extending special abstract Java classes which are then available
created for the second experiment: one passing x and y to a func- via a special namespace. This, however, creates a dependency on
tion and one doing the multiplication in the query. Again, there is both Java and Apache Jena. All of this also holds for SPIN as it is
strong evidence that both mappings are different (p-value = built on top of Jena.
0.0000000204), and this time in favor of M2. From these addi-
On R2RML extensions. RML [8] and xR2RML [13] extended
tional experiments, we conclude that further experiments – both in
R2RML to provide support for generating RDF from different
terms of dataset size and varying complexity of functions – are
types of structured resources such as XML and CSV. One can see
necessary to evaluate performance
how the ideas presented in this paper can easily be merged with
Table 3: Average, maximum and minimum execution time in those initiatives. At this stage, however, we choose to extend
milliseconds for 100 runs with each mapping for the two addi- R2RML validate our ideas and will consider RML at a later stage.
tional experiments.
6. CONCLUSIONS AND FUTURE WORK
1 variable 2 variables Capturing procedural knowledge in R2RML either relies on the
M1 M2 M1 M2 underlying relational database technology or on data pre-
Average 1,646.10 1,716.76 1,980.22 1,729.95 processing. If one is willing to trade tractability in for richer map-
Standard Deviation 154.53 197.88 318.57 285.58 pings, sharing and declaring richer mappings is possible.
Min out of 100 runs 1,305.00 1,290.00 1,321.00 1,058.00
We presented R2RML-F, which extends R2RML with treating
Max out of 100 runs 2,115.00 2,102.00 2,622.00 2,304.00
function calls as a term map. Using a use case from the geospatial
domain, we demonstrated our approach and conducting an exper-
5. RELATED WORK iment to evaluate its performance with a mapping relying on func-
We have to note that functions in transformations have been stud- tions provided by the underlying database technology. Our initial
ied in different domains, such as model-to-model transformations, results show that our approach is viable and that there seems to be
for which specifications have been developed. One noteworthy little impact on the performance.
example of such a specification in that domain is Que- Future work includes additional experiments to validate our find-
ry/View/Transformation (QVT) defined by the Object Manage- ings and developing additional scenarios and use cases to moti-
ment Group allowing one access to operators, constructs and func- vate the need for incorporating functions in a mapping, e.g., those
tions to transform UML into, for instance, ER [14]. QVT and calling web services.
similar approaches have been adopted in the Semantic Web com-
munity to transform meta-models in e.g., UML into OWL ontolo- 7. ACKNOWLEDGMENTS
gies [16], but this is a different problem than the one we address. This study is supported by the Science Foundation Ireland (Grant
In this study, we incorporated the notion in a W3C Recommenda- 13/RC/2106) as part of the ADAPT Centre for Digital Content
tion for publishing data as RDF. The adoption of RDF allows one Platform Research (http://www.adaptcentre.ie/) at Trinity College
to furthermore publish the functions that were developed. Dublin. We thank the Ordnance Survey Ireland (OSi) for permit-
ting us to use their boundaries dataset for the purposes of this
On capturing functions in mappings. Hert et al. presented a
research project. Within OSi, we are especially grateful for the
survey in which they investigated the capabilities of RDB-2-RDF
input and domain expertise provided by Lorraine McNerney and
tools, both direct and annotated [9]. One of the aspects they inves-
Éamonn Clinton.
tigated was “Transformation Functions”, which are user-defined
functions to transform the (syntactic) representation in RDF. In 8. REFERENCES
their survey, they consider this aspect covered when the underly- [1] M. Arenas, A. Bertails, E. Prud’hommeaux, J. Sequeda. A
ing database technology supports these conversions. Our approach Direct Mapping of Relational Data to RDF. W3C Recom-
is different as we capture those functions in the mapping. mendation, W3C, Sep. 2012. https://www.w3.org/TR/rdb-
ECMAScript provides the ability to load (external) scripts, and direct-mapping/
hence functionality not necessarily available by the underlying
technology. [2] T. Berners-Lee. Relational Databases on the Semantic Web,
1998. Via https://www.w3.org/DesignIssues/RDB-
XSPARQL [4] – initially developed to mediate between XML and RDF.html, last accessed January 2015.
RDF via SPARQL and XQuery – has recently been used as an
R2RML processor [7]. Since the XQuery specification prescribes [3] P. A. Bernstein and S. Melnik. Model management 2.0: ma-
support for defining user-defined functions, one should be able to nipulating richer mappings. In C. Y. Chan, B. C. Ooi, and A.
Zhou, editors, Proceedings of the ACM SIGMOD Interna-
tional Conference on Management of Data, Beijing, China,
10 June 12-14, 2007, pages 1–12. ACM, 2007.
Unlike the previous experiment, the outcome of the function
using the underlying technology does not need to be cast to a
different data type and therefore no third mapping to analyze
11
that overhead is needed. https://jena.apache.org/
[4] S. Bischof, S. Decker, T. Krennwallner, N. Lopes, and A. Search, volume 7538 of LNCS, pages 34–52. Springer, 2012.
Polleres. Mapping between RDF and XML with XSPARQL. [16] J. Zedlitz, J. Jörke, and N. Luttenberger. Knowledge Tech-
J. Data Semantics, 1(3):147–185, 2012. nology: Third Knowledge Technology Week, KTW 2011, Ka-
[5] D. Brickley and R. V. Guha. RDF Schema 1.1. W3C Rec- jang, Malaysia, July 18-22, 2011. Revised Selected Papers,
ommendation, W3C, Feb. 2014. https://www.w3.org/TR/rdf- chapter From UML to OWL 2, pages 154–163. Springer Ber-
schema/ lin Heidelberg, Berlin, Heidelberg, 2012.
[6] S. Das, S. Sundara, and R. Cyganiak. R2RML: RDB to RDF APPENDIX
Mapping Language. W3C Recommendation, W3C, Sep. Here we provide listings referred to in the text.
2012. https://www.w3.org/TR/r2rml/
<#TriplesMap1>
[7] D. Dell’Aglio, A. Polleres, N. Lopes, and S. Bischof. Query- rr:logicalTable [
ing the web of data with XSPARQL 1.1. In R. Verborgh and rr:sqlQuery """SELECT id, name, ST_AsText(geom)
AS geom FROM boundaries.county""" ;
E. Mannens, editors, Proceedings of the ISWC Developers ] ;
Workshop 2014, co-located with the 13th International Se- rr:subjectMap [
mantic Web Conference (ISWC 2014), Riva del Garda, Italy, rr:template "http://data.example.com/county/{id}" ;
] ;
October 19, 2014, volume 1268 of CEUR Workshop Pro- rr:predicateObjectMap [
ceedings, pages 113–118. CEUR-WS.org, 2014. rr:predicate ex:name ;
rr:termType rr:Literal;
[8] A. Dimou, M. Vander Sande, P. Colpaert, R. Verborgh, E. rr:objectMap [ rr:column "name" ];
Mannens, and R. Van de Walle. RML: A generic language ] ;
for integrated RDF mappings of heterogeneous data. In C. rr:predicateObjectMap [
rr:predicate ex:point ;
Bizer, T. Heath, S. Auer, and T. Berners-Lee, editors, Pro- rr:objectMap [
ceedings of the Workshop on Linked Data on the Web co- rr:termType rr:Literal;
located with the 23rd International World Wide Web Confer- rrf:functionCall [
rrf:function <#Transform> ;
ence (WWW 2014), Seoul, Korea, April 8, 2014, volume rrf:parameterBindings (
1184 of CEUR Workshop Proceedings. CEUR-WS.org, [ rr:column "geom" ]
2014. ) ;
] ;
[9] M. Hert, G. Reif, and H. C. Gall. A comparison of RDF-to- ] ;
RDF mapping languages. In C. Ghidini, A. N. Ngomo, S. N. ] ;
.
Lindstaedt, and T. Pellegrini, editors, Proceedings the 7th In- <#Transform>
ternational Conference on Semantic Systems, I-SEMANTICS rrf:functionName "transform" ;
2011, Graz, Austria, September 7-9, 2011, ACM Internation- rrf:functionBody """
// Omitted
al Conference Proceeding Series, pages 25–32. ACM, 2011. """ ;
[10] O. Kovalenko, C. Debruyne, E. Serral, and S. Biffl. Evalua- .
tion of technologies for mapping representation in ontolo- Listing 4: An R2RML-F mapping transforming points from a
gies. In R. Meersman, H. Panetto, T. S. Dillon, J. Eder, Z. geometry cast to a string with a function captured in the map-
Bellahsene, N. Ritter, P. D. Leenheer, and D. Dou, editors, ping (mapping M2). Differences wrt Listing 3 are highlighted.
On the Move to Meaningful Internet Systems: OTM 2013 <#TriplesMap1>
Conferences - Confederated International Conferences: rr:logicalTable [
rr:sqlQuery """SELECT id, name,
CoopIS, DOA-Trusted Cloud, and ODBASE 2013, Graz, ST_AsText(ST_Transform(geom,4326))
Austria, September 9-13, 2013. Proceedings, volume 8185 of AS geom FROM boundaries.county""" ;
LNCS, pages 564–571. Springer, 2013. ] ;
rr:subjectMap [
[11] H. Knublauch, J. A. Hendler, K. Idehen. SPIN – Overview rr:template "http://data.example.com/county/{id}" ;
and Motivation. W3C Member Submission, W3C, Feb. 2011. ] ;
rr:predicateObjectMap [
https://www.w3.org/Submission/spin-overview/ rr:predicate ex:name ;
rr:termType rr:Literal;
[12] D. McGuinness, T. Lebo, and S. Sahoo. PROV-O: The rr:objectMap [ rr:column "name" ];
PROV ontology. W3C Recommendation, W3C, Apr. 2013. ] ;
http://www.w3.org/TR/2013/REC-prov-o-20130430/. rr:predicateObjectMap [
rr:predicate ex:point ;
[13] F. Michel, L. Djimenou, C. Faron-Zucker, and J. Montagnat. rr:objectMap [
Translation of relational and non-relational databases into rr:objectMap [ rr:column "geom" ];
] ;
RDF with xR2RML. In V. Monfort, K. Krempels, T. A. ] ;
Majchrzak, and Z. Turk, editors, WEBIST 2015 - Proceed- .
ings of the 11th International Conference on Web Infor- <#Transform>
mation Systems and Technologies, Lisbon, Portugal, 20-22 rrf:functionName "transform" ;
rrf:functionBody """
May, 2015, pages 443–454. SciTePress, 2015. // Omitted
""" ;
[14] The Object Management Group. Meta Object Facility (MOF) .
2.0 Query/View/-Transformation Specification, 2007.
Listing 5: An R2RML-F mapping transforming points from a
[15] J. Unbehauen, S. Hellmann, S. Auer, and C. Stadler. geometry using a database’s built-in function, which is then
Knowledge extraction from structured sources. In S. Ceri and cast to a string (mapping M3). Differences wrt Listing 3 are
M. Brambilla, editors, Search Computing - Broadening Web highlighted.