R2RML: RDB to RDF Mapping Language

This specification describes R2RML, a language for expressing customized mappings from relational databases to RDF datasets. Such mappings provide the ability to view existing relational data in the RDF data model, expressed in a structure and target vocabulary of the mapping author's choice.

Besides the R2RML language, this working group will also define a fixed “default mapping” from relational databases to RDF. In the default mapping of a database, the structure of the resulting RDF graph directly reflects the structure of the database, the target RDF vocabulary directly reflects the names of database schema elements, and neither structure nor target vocabulary can be changed. With R2RML on the other hand, a mapping author can define highly customized views over the relational data.

An R2RML mapping defines a mapping from a relational database to an RDF dataset. This mapping itself is represented as an RDF graph. In other words, RDF is used not just as the target data model of the mapping, but also as a formalism for representing the R2RML mapping itself. An RDF graph that represents an R2RML mapping is called a mapping graph.

An R2RML mapping consists of one or more structures called TriplesMaps.

Each TriplesMap contains a reference to a logical table in the input database. A logical table can be one of the following:

1. A base table that exists in the input SQL schema.
2. A view that exists in the input SQL schema.
3. A valid SQL query against the input schema.

Furthermore, a TriplesMap contains a rule for mapping a logical table row to a set of RDF triples. The RDF triples generated from one row all share the same subject, defined by a structure called an RDFSubjectTermMap. The predicates and objects generated from the row are defined by RDFTermMaps, one per generated triple. The RDFTermMaps are rules for generating RDF nodes from the table row's values.

The output of an R2RML mapping is an RDF dataset. The RDF triples in the dataset are the result of applying the mapping rule of each TriplesMap to the rows of its logical table.

By default, all RDF triples are in the unnamed default graph of the RDF dataset. A TriplesMap can contain optional rules that place some or all of the triples into named graphs instead.

In this document, examples assume the following namespace prefix bindings unless otherwise stated:

Throughout the document, boxes containing Turtle markup and SQL data will appear. These boxes are color-coded. Gray boxes contain RDFS definitions of R2RML vocabulary terms:

# This box contains RDFS definitions of R2RML vocabulary terms

Yellow boxes contain example fragments of R2RML mappings in Turtle syntax:

# This box contains example R2RML mappings

Blue and green boxes contain example input and output data, respectively:

# This box contains example input tables

# This box contains example output RDF triples or fragments

This section defines the RDF properties that have the RDFTermMap class as their domain.

rr:property rdfs:range rdf:Property .

rr:column rdfs:range xsd:string .

rr:propertyColumn rdfs:range xsd:string .

rr:inverseExpression rdfs:range xsd:string .

This optional property specifies an expression that allows, at query processing time, use of indexes on any (underlying) relational table when accessing based on a value of a column (defined as an expression) in the logical table. The specified expression must be usable in the WHERE clause of a SQL query, with substitution of alias for the (logical) table associated with the parent TriplesMap class. Specifically, all the column names associated with the {alias.} must be actual column names in the associated logical table.

For example, for the deptId column in the logical table shown in Section 3.3.1.1, the inverse expression could be defined as follows:

"{alias.}deptno = substr({alias.}deptId,length('Department')+1)"

This facilitates the use of an index on the deptno column of the dept table. Note that the actual alias (say d) used for the dept table is used to expand {alias.} (to d.).

rr:datatype rdfs:range rdfs:Datatype .

This optional property specifies the datatype for the object value component of the RDFTermMap instance. If not specified, the datatype for the object value will be derived from the column definition of the logical table. In the following example, the datatype of the object value component of an RDFTermMap instance is specified to be a positive integer.

[] rr:datatype xsd:positiveInteger .

If the datatype was not specified and the rr:column that was used is dept:deptno, then the rr:datatype property would become xsd:integer (based on DEPT table definiton), as if it was specified as follows:

[] rr:datatype xsd:integer .

If the rr:datatype is not specified and the database column is of a string type (such as VARCHAR), then the rr:datatype would be considered as an RDF plain literal.

rr:language rdfs:range xsd:string .

This optional property specifies the language for the object value component of the RDFTermMap instance. This property is applicable only if the datatype of the object value is RDF plain literal. In the following example, the language tag for the object value component is specified to be US English.

[] rr:language "en-us" .

rr:columnGraphIRI rdfs:range <Set of valid IRI references> .
rr:columnGraph rdfs:range xsd:string .

These two properties may be used to specify the RDF named graph for the triples that are constructed with the (property, object) pair of the RDFTermMap. The two properties differ as follows: the value for rr:columnGraphIRI must be a graph IRI, whereas the value for rr:columnGraph must be of a column of the logical table whose values will be used as the graph IRIs.

In the following example, the RDF named graph to be used for storing the triple generated using the (property, object) pair (emp:name, "ename") corresponding to an RDFTermMap is specified by the IRI emp:empNameGraph.

[] rr:property emp:name; 
   rr:column "ename"; 
   rr:columnGraphIRI emp:empNameGraph
.

rr:constantValue rdfs:range rdfs:Resource .

rr:RDFTypeProperty rdfs:range xsd:string .

This section describes the subclasses of the RDFTermMap class. These classes comprise specialized RDF term mappings namely to IRIs, blank nodes, and literals.

Figure 2: An RDF Graph describing the subclasses of the RDFTermMap class

The IRIorBlankNodeMap class represents the mapping to any RDF term that can appear as subject of an RDF triple: IRIs or blank nodes.

rr:IRIorBlankNodeMap rdfs:subClassOf rr:RDFTermMap .

The IRIMap class represents the mapping to a RDF Resource.

rr:IRIMap rdfs:subClassOf rr:IRIorBlankNodeMap .

The BlankNodeMap class represents the mapping to a RDF blank node.

rr:BlankNodeMap rdfs:subClassOf rr:IRIorBlankNodeMap .

The LiteralMap class represents the mapping to a RDF literal.

rr:LiteralMap rdfs:subClassOf rr:RDFTermMap .

TriplesMap is an RDFS class that allows specification of a mapping of the rows in a logical table, represented by a SQL query, or the name of a table or view and its owner, into RDF triples. Properties of a TriplesMap instance allows specification of various aspects of the mapping such as, mapping of (some of) the columns in the logical table to RDF (property, object) pairs using RDFTermMap, name of the RDF graph(s) that would store the RDF triples, and so on.

Figure 3: An RDF Graph describing the TriplesMap class and its properties

This section defines the RDF properties that have the TriplesMap class as their domain.

rr:logicalTable rdfs:range xsd:String .

This property specifies the logical table (i.e., a valid SQL query or a table or view name plus its owner name) whose rows are mapped to RDF triples by this TriplesMap instance. Note that each row in the logical table is mapped to a resource which is used as the subject for the generated RDF triples describing the resource.

The following example specifies that the TriplesMap instance TriplesMap1 maps the rows in the logical table defined by the SQL query to RDF triples.

<#TriplesMap1> rr:logicalTable 
                                """Select 'Department' || deptno AS deptId
                                        , deptno
                                        , dname
                                        , loc
                                   from dept""" .

The cardinality of this property, for a TriplesMap instance, must be exactly 1. That is, a TriplesMap instance must have exactly one value for this property. Also, note that the logical table should not have duplicate column names or unnamed columns.

rr:subjectMap  rdfs:range rr:IRIorBlankNodeMap .

rr:propertyObjectMap rdfs:range rr:RDFTermMap .

rr:class rdfs:range rdfs:Class .

This property specifies the RDFS class associated with a TriplesMap instance. In the generated RDF data, the resource corresponding to a row in the logical table will become an instance of this RDFS class.

In the following example, TriplesMap1 is associated with the RDFS class xyz:dept using the rr:class property. This leads to the creation of xyz:dept as an RDFS class in the RDFS schema generated from the mapping specification and in the generated RDF data, RDF resources being created for each row in the logical table associated with TriplesMap1 become instances of the xyz:dept class.

<#TriplesMap1> rr:class xyz:dept .

Given the above mapping and the sample data in the DEPT table, the following triple will be generated

       _:Department10 rdf:type xyz:dept .

rr:tableGraphIRI rdfs:range <Set of valid IRI references> .

This property specifies the graph IRI that would contain all the RDF triples in a TriplesMap instance.

Given the following example mapping,

<#TriplesMap1> rr:tableGraphIRI xyz:DeptGraph .

all the RDF triples in TriplesMap1 would be stored in the RDF named graph

 xyz:DeptGraph 

rr:rowGraph rdfs:range xsd:string .

rr:foreignKeyMap rdfs:range rr:ForeignKey .

ForeignKey is an RDFS class that allows specification of the mapping that describes a foreign key relationship.

rr:ForeignKey a rdfs:Class .

This class has three components: a key that specifies the column constraint in the child(referring) table, the TriplesMap corresponding to the parent(referenced) table, and the join condition corresponding to the foreign key constraint. Conceptually, a ForeignKey instance is similar to a propertyObjectMap where the property name is identified by the key and a join condition is specified that can be used to obtain the object value from the TriplesMap corresponding to the parent (logical) table.

Figure 4: An RDF Graph describing the ForeignKey class and its properties

This section defines the RDF properties that have the ForeignKey class as their domain.

rr:key rdfs:range rdf:Property .

This property specifies the constraint component of the ForeignKey instance. The following example identifies the IRI emp:c_ref_deptno as a property that represents a foreign key constraint.

[] rr:key emp:c_ref_deptno .

rr:parentTriplesMap rdfs:range rr:TriplesMap .

This property specifies the TriplesMap corresponding to the parent table component, of the ForeignKey instance. The following example identifies the TriplesMap corresponding to the parent logical table.

[] rr:parentTriplesMap xyz:dept .

rr:joinCondition rdfs:range xsd:string .

This property specifies the join condition of the ForeignKey instance. The following example shows a join condition to be used to obtain the object values from the parent logical table.

[] rr:joinCondition "{child.}deptno = {parent.}deptno" .

In this section we show an example relational schema and then map the example schema to RDF using the Turtle syntax.

We illustrate our example with the use of the following three relational tables, along with sample data.

<#TriplesMap1>
    a rr:TriplesMap;
    rr:logicalTable "
       Select ('_:Department' || deptno) AS deptId
            , deptno
            , dname
            , loc
         from dept
       ";
    rr:class xyz:dept;
    rr:tableGraphIRI xyz:DeptGraph;
    rr:subjectMap [ a rr:BlankNodeMap; rr:column "deptId";
                    rr:InverseExpression "{alias.}deptno = substr({alias.}deptId,length('_:Department')+1)"];
    rr:propertyObjectMap [ rr:property dept:deptno; rr:column "deptno"; rr:datatype xsd:positiveInteger ];
    rr:propertyObjectMap [ rr:property dept:name; rr:column "dname" ];
    rr:propertyObjectMap [ rr:property dept:location; rr:column "loc" ];
    rr:propertyObjectMap [ rr:property dept:COMPANY; rr:constantValue "XYZ Corporation" ];
.

Content of the logical table used in this mapping:

The set of RDF triples generated using the above mapping:

<#TriplesMap2>
    a rr:TriplesMap;
    rr:logicalTable "
       Select ('<xyz.com/emp/' || empno||'>') AS empURI
            , empno
            , ename
            , ('<xyz.com/emp/job/'|| job||'>') AS jobTypeURI
            , job
            , deptno
            , ('<xyz.com/emp/etype/'|| etype||'>') AS empTypeURI
            , etype
            , ('<xyz.com/graph/'|| job || '/' || etype||'>') AS graphURI
       from emp
       ";
    rr:class xyz:emp;
    rr:subjectMap [ rr:column "empURI" ];
		
    rr:rowGraph "graphURI";
		
    rr:propertyObjectMap [ rr:RDFTypeProperty emp:jobtype; rr:column "jobTypeURI" ];
    rr:propertyObjectMap [ rr:RDFTypeProperty emp:emptype; rr:column "empTypeURI" ];
		
    rr:propertyObjectMap [ rr:property emp:empno; rr:column "empno" ];
    rr:propertyObjectMap [ rr:property emp:name; rr:column "ename"; rr:columnGraphIRI emp:empNameGraph ];
    rr:propertyObjectMap [ rr:property emp:job; rr:column "job" ];
    rr:propertyObjectMap [ rr:property emp:deptNum; rr:column "deptno" ];
    rr:propertyObjectMap [ rr:property emp:etype; rr:column "etype" ];
    rr:foreignKeyMap [
      rr:key emp:c_ref_deptno;
      rr:parentTriplesMap xyz:dept;
      rr:joinCondition "{child.}deptno = {parent.}deptno";
    ];
    .

Content of the logical table used in this mapping:

The set of RDF triples generated using the above mapping (the two generated graphs are shown separately below):

<#TriplesMap3>
    a rr:TriplesMap;
    rr:logicalTable "
      Select ('<xyz.com/emp/' || id||'>') AS empId
           , ('<xyz.com/emp/likes/' || likeType||'>') AS empLikes
           , likedObj
        from likes
      ";
    rr:tableGraphIRI xyz:LikesGraph;
    rr:subjectMap [ a rr:IRIMap; rr:column "empId"];
    rr:propertyObjectMap [ rr:propertyColumn "empLikes" rr:column "likedObj"]
    .

Content of the logical table used in this mapping:

The set of RDF triples generated using the above mapping:

$Log: Overview.html,v $
Revision 1.5  2010/10/27 13:20:08  mhausenb
fixed expected pub date

Revision 1.4  2010/10/27 12:54:17  mhausenb
fix some minor things such as typos, pubrules now just complains re missing resources (but that's fine)

Revision 1.3  2010/10/27 12:42:04  mhausenb
fixing pubrules issues in SOTD section

Revision 1.2  2010/10/27 12:29:44  mhausenb
fix minor bug with CSS

Revision 1.1  2010/10/27 12:26:42  mhausenb
init FPWD R2RML as per WG decision http://www.w3.org/2010/10/19-rdb2rdf-minutes.html#item02 and http://www.w3.org/2010/10/26-rdb2rdf-minutes.html#item02