The ontologization of non-ontological resources has led to the design of several speci c methods, techniques and tools. Among those techniques, we have the Re-engineering Patterns. More speci cally, we have the Patterns for re-engineering NORs (PR-NOR) that de ne a procedure that transforms the NOR terms into ontology representational primitives. Currently, the W3C RDB2RDF Working Group is at the nal stage of formalizing R2RML, a language for describing mappings among RDB elements and RDF. In this paper we claim that it is possible to combine PR-NORs with R2RML mappings for building ontologies from relational database content, i.e., transforming the database content into an ontology schema by using Re-engineering Patterns and R2RML mappings.
During the last decade, speci c methods, techniques and tools were proposed
for building ontologies from existing knowledge resources. When we are
transforming non-ontological resources (NORs) [
According to the survey described in [
The majority of non-ontological resources underpinning the Web are
implementing in Relational Databases (RDB) [
As we mentioned above, we provided a general algorithm to do the transformation for each of PR-NORs. However, in order to actually do the transformation, a user has to implement this algorithm in his choice of programming language (Java, Scala, etc). On the other hand, we observed that although R2RML mappings are normally used to generate ontology instances from database content (Population transformation), we gured out that when the database content follows speci c patterns such as PR-NORs, then R2RML mappings can be useful in this situation. In this paper we propose to combine PR-NORs with R2RML mappings for building ontologies from relational database content, i.e., transforming the database content into an ontology schema by using Re-engineering Patterns and R2RML mappings.
The rest of the paper is organized as follows. Section 2 provides the background knowledge, by describing PR-NORs and R2RML. Then, Section 3 presents how we combine the PR-NORs with R2RML mappings for building the ontolo1http://ontologydesignpatterns.org 2http://www.w3.org/2001/sw/rdb2rdf/ 3http://www.w3.org/TR/r2rml/ gies from relational database content, and includes two examples. Finally, Section 4 presents the conclusions and future work. 2
In this section we provide a brief description of the PR-NORs and R2RML. 2.1
Patterns for Re-engineering Non-Ontological Resources
The Patterns for Re-engineering Non-Ontological Resources (PR-NOR) [
5http://ontologydesignpatterns.org/wiki/Submissions:ReengineeringODPs { Name of the pattern { Identi er of the pattern { Use case, description in natural language of the re-engineering problem addressed by the pattern { Input, description in natural language of the NOR, and its graphical representation { Output, description in natural language of the ontology created after applying the pattern, and its graphical representation { Process, algorithm for the re-engineering process 2.2
R2RML
R2RML6 is a language for expressing mappings from relational databases to
RDF datasets. These mappings provide the ability to view existing relational
data in the RDF data model, expressed in a target ontology. The input to an
R2RML mapping is a relational database. The output is an RDF dataset that
uses predicates and types from the target ontology. It is worth mentioning that
R2RML mappings are themselves expressed as RDF graphs and written down
in Turtle syntax [
In a nutshell, an R2RML mapping points to logical tables to get data from the database. A logical table can be (1) a database table, (2) a view, or (3) a valid SQL query. Each logical table is mapped to RDF using a triples map. A triples map de nes rules that map each row in the logical table to a set of RDF triples. Those rules have two main parts (1) a subject map, which generates the subject of all RDF triples that will be created from a logical table row; and (2) multiple predicate-object maps that consist of predicate maps and object maps (or referencing object maps). Triples are produced by combining the subject map with a predicate map and object map, and applying these three to each logical table row. It is possible that a triples map can contain graph maps that place some or all of the triples into named graphs, but by default, all RDF triples are in the default graph of the output dataset.
Next, we present a basic example in order to illustrate how to specify R2RML mappings7. Let us consider the database depicted in Figure 3. This database contains a table, one primary key, two columns, and one row. For the that database we have the following R2RML mapping @prefix r r : <http : / /www. w3 . org / ns / r2rml#> . @prefix f o a f : <http : / / xmlns . com/ f o a f /0.1/ > . @prefix r d f : <http : / /www. w3 . org /1999/02/22 rdf syntax ns#> . @prefix ex : <http : / / example . com/> . @prefix xsd : <http : / /www. w3 . org /2001/XMLSchema#> . @base <http : / / example . com/ base/> . <TriplesMap1> a r r : TriplesMap ; r r : l o g i c a l T a b l e [ r r : tableName " Student " ] ; r r : subjectMap [ r r : c l a s s f o a f : Person ;
r r : template " http : / / example . com/ Student /fIDg/fNameg " ; ] ; r r : predicateObjectMap [ r r : p r e d i c a t e ex : i d ;
r r : objectMap [ r r : column "ID " ; ] ] ; r r : predicateObjectMap [ r r : p r e d i c a t e f o a f : name ;
r r : objectMap [ r r : column "Name" ] ] .
Finally, it is worth mentioning that neither the RDB2RDF Use Cases and Requirements 8 nor the R2RML mappings in the R2RML Test Cases document9 provide or say anything about generating ontologies from database content.
7Please refer to the R2RML speci cation and its testcases to check a detailed list of R2RML mapping examples.
8http://www.w3.org/TR/rdb2rdf-ucr/ 9http://www.w3.org/2001/sw/rdb2rdf/test-cases/
Combining PR-NORs and R2RML mappings In this section we present how to generate ontologies from database content by using PR-NORs and R2RML mappings. Our combination of PR-NORs and R2MRL mappings is two-fold, rst (1) we want to specialize the PR-NORs that perform a TBox transformation by specifying Relational databases as NOR, (2) we want to show that it is possible to generate ontology schema triples using R2RML mappings.
Using R2RML mappings for transforming PR-NOR patterns brings two bene ts. The rst bene t is since R2RML mappings are expressed in RDF, we can store and reuse them. The second is, there are already several R2RML engines10, therefore, it will be possible to execute the mappings and generate the ontologies in a short time.
Using our approach, each PR-NOR has the corresponding R2RML mapping. The mappings will be executed by an R2RML engine and the result of that execution will generate an ontology represented as an RDF document.
All the patterns, mappings, and some other les (sql dump, result in graphical representation etc) are available here at: { Pattern Description : mappingpedia:pattern/SchemaPatterns/fPatternIDg { Mapping Algorithm : mappingpedia:pattern/SchemaPatterns/fPatternIDg/algorithm.txt { Mapping Example : mappingpedia:pattern/SchemaPatterns/fPatternIDg/mappingexample.ttl { SQL General : mappingpedia:pattern/SchemaPatterns/fPatternIDg/sql-general.sql { SQL Example : mappingpedia:pattern/SchemaPatterns/fPatternIDg/sql-example.sql { RDF Result Example : mappingpedia:pattern/SchemaPatterns/fPatternIDg/resultexample.nt Where mappingpedia represents http://mappingpedia.linkeddata.es/
Next, we show examples of how to build R2RML mappings that correspond to the PN-NORs patterns. We use snow ake model as the representation of classi cation schema pattern and term-based relational model as the representation of thesaurus pattern.
PR-NOR-CLTX-03 : Pattern for re-engineering a classi cation scheme
following the snow ake data model into an ontology schema A
classication scheme is a rooted tree of terms, in which each term groups entities by
some particular degree of similarity. The semantics of the hierarchical relation
between parent and children terms may vary depending on the context. The
snow ake data model [
The ontology generated will be based on the taxonomy architectural pattern
(AP-TX-01) [
Next we present the procedure that generates R2RML mapping corresponding to the pattern. First, create an rr:TriplesMap instance for every table with the table name as its rr:logicalTable value. Then create an rr:SubjectMap instance for the TriplesMap with rdfs:Class as its rr:class and concatenation of namespace base and primary key of the table as its rr:template value. Additionaly, the user may provide an rr:PredicateObjectMap instance that speci es the name of the class. If the table doesn't have a foreign key, it means that the table is mapped into the root class of the ontology. Otherwise, create an rr:PredicateObjectMap instance with rr:objectMap that joins the foreign key with the referenced primary key.
Input: The tables of database tables, the URI of the target class classU RI
Output: R2RML Mapping Document M D
1: MD createMappingDocument()
2: for t 2 tables do
3: T M createTriplesMap()
4: T M:logicalT able:tableName t.tableName
5: T M:subjectMap:class rdfs:Class
6: T M:subjectMap:template CONCAT(classURI, table.PKColumn)
7: T M:predicateObjectMap[0]:predicate rdfs:label
8: T M:predicateObjectMap[0]:objectMap:column t.LabelColumn
9: if t:P K = fg then
10: T M:predicateObjectMap[
" http : / / example . org / r e s o u r c e / P r o f e s s i o n e f i d 0 g " ; ] ; r r : predicateObjectMap [ r r : p r e d i c a t e r d f s : l a b e l ;
r r : objectMap [ r r : column " d e s c 0 " ] ; ] ; r r : predicateObjectMap [ r r : p r e d i c a t e r d f s : subClassOf ; r r : objectMap [ r r : c o n s t a n t
" http : / / example . org / r e s o u r c e / P r o f e s s i o n e " ] ; ] ; . <T r i p l e s M a p P r o f e s s i o n e 2 > a r r : TriplesMap ; r r : l o g i c a l T a b l e [ r r : tableName " P r o f e s s i o n e 2 " ] ; r r : subjectMap [ r r : c l a s s r d f s : C l a s s ; r r : termType r r : IRI ; r r : template
" http : / / example . org / r e s o u r c e / P r o f e s s i o n e f i d 2 g " ; ] ; r r : predicateObjectMap [ r r : p r e d i c a t e r d f s : l a b e l ;
r r : objectMap [ r r : column " d e s c 2 " ] ; ] ; r r : predicateObjectMap [ r r : p r e d i c a t e r d f s : subClassOf ; r r : objectMap [ r r : termType r r : IRI ; r r : parentTriplesMap <T r i p l e s M a p P r o f e s s i o n e 1 >; r r : j o i n C o n d i t i o n [
r r : c h i l d " i d 1 " ; r r : p a r e n t " i d 1 " ; ] ; ] ; ] ; .
PR-NOR-TSTX-02 : Pattern for re-engineering a thesaurus following
the relation-based data model into an ontology schema A thesaurus
represents the knowledge of a domain with a collection of terms and a limited
set of relations between them. The relation-based data model [
As an example, the AGROVOC Thesaurus is an structured and controlled vocabulary designed to cover the terminology of all subject elds in agriculture, forestry, sheries, food and related domains. This thesaurus is available at http:// www.fao.org/agrovoc/. See Figure. 6 for the graphical representation of the thesaurus.
The ontology generated will be based on the lightweight ontology
architectural pattern (AP-LW-01)[
Next, we present the procedure to generate R2RML mappings corresponding to this pattern. First, create an rr:TriplesMap instance whose rr:logicalTable is a view of join result of Terminology table, Terms Relationship table, and Relationship Type table. We let the user decide whether the join type is INNER or LEFT OUTER. In the view, specify also the translation from Relationship Type table values into skos properties using SQL CASE. Then, create an instance of rr:SubjectMap with rdfs:Class as its rr:class. The URI values is speci ed through rr:template as the concatenation of Term class namespace with the value of the vided to specify the class name. Then, create another rr:PredicateObjectMap instance that maps a property to the the relationship between one term with another speci ed in the SQL CASE value provided in the view.
Input: Table Term T blT erm, Table Relationship T blRel, Table Relationship
type T blRelT ype, Term Class URI classU RI
Output: R2RML Mapping Document M D
1: MD createMappingDocument()
2: T M createTriplesMap()
3: V = T blT erm ./ T blRel ./ T blRelT ype
4: T M:logicalT able:sqlQuery V
5: T M:subjectMap:class rdfs : Class
6: T M:subjectMap:template CONCAT(classURI, TblRel.TermCode1)
7: T M:predicateObjectMap[0]:predicate rdfs : label
8: T M:predicateObjectMap[0]:objectMap:column T blT erm:T erm
9: T M:predicateObjectMap[
CONCAT (classURI; T blRel:T ermCode2)
11: T M:predicateObjectMap[
CONCAT (classURI; T blRel:T erm) 13: PUT(MD, T M) 14: return MD Listing 1.2. R2RML mappings corresponding to the example of Thesaurus Relation-based Data Model <TriplesMapTerm> a r r : TriplesMap ; r r : l o g i c a l T a b l e [ r r : sqlQuery """ SELECT t . TermCode , t . Term , t l . TermCode2 , l t . LinkDesc , l t . LinkTypeID , CASE l t . LinkAbr
WHEN 'BT' THEN ' s k o s : broader ' WHEN 'NT' THEN ' s k o s : narrower '
WHEN 'RT' THEN ' s k o s : r e l a t e d ' END AS linkURIObject , CASE l t . LinkAbr
WHEN 'UF' THEN ' s k o s : a l t L a b e l '
END AS linkURIData FROM agrovocterm t LEFT OUTER JOIN t e r m l i n k t l
ON t . TermCode = t l . TermCode1 LEFT OUTER JOIN l i n k t y p e l t
ON t l . LinkTypeID = l t . LinkTypeID " " " ] ; r r : subjectMap [ r r : c l a s s r d f s : C l a s s ; r r : termType r r : IRI ; r r : template
" http : / / example . org / r e s o u r c e /TermfTermCode g " ; ] ; r r : predicateObjectMap [ r r : p r e d i c a t e r d f s : l a b e l ;
r r : objectMap [ r r : column "Term " ] ; ] ; r r : predicateObjectMap [ r r : predicateMap [ r r : column " linkURIObject " ; r r : termType r r : IRI ] ;
r r : objectMap [ r r : template " http : / / example . org / r e s o u r c e /TermfTermCode2 g " ] ; ] ; r r : predicateObjectMap [ r r : predicateMap [ r r : column " linkURIData " ; r r : termType r r : L i t e r a l ] ;
r r : objectMap [ r r : template " http : / / example . org / r e s o u r c e /TermfTerm g " ] ; ] ; .
We have seen two examples of using R2RML mappings in order to generate
ontologies from PR-NORs. There are other approaches for this goal, although
our approach is better for several reasons. For example, using other RDB2RDF
languages instead of R2RML, such as R2O [
In this paper we have presented an approach that combines PR-NORs with R2RML mappings for building ontologies from relational database content, i.e., transforming the database content into an ontology schema by using Re-engineering Patterns and R2RML mappings. Furthermore, we have seen that besides for generating data-triples (triples that describes instances of an ontology), R2RML mappings are useful also to generate schema-triples (triples that describe the schema of an ontology).
In the future, we will continue identifying other Re-engineering patterns that may take bene t from R2RML mappings. We will explore the possibility to combine R2RML mappings with other data-source type, such as XML, CSV or spreadsheets. Because R2RML mappings are RDF documents, it is possible to store those mappings in a triple store. Once those mappings have been stored in the triple store and annotated with meta-data properties, users can pose query the triple store in order to get all mappings correspond to a speci c pattern. For example, user can pose a SPARQL query SELECT * FROM f?m a mapping. m hasPattern ?p. FILTER REGEX(?p, "Snowflake")g, and the answers will be all mappings corresponding to the snow ake data model pattern. The system is currently under development and being populated with mappings and patterns and we plan to report this system as future work.
Acknowledgments: This work has been supported by the PlanetData (FP7257641), BabelData (TIN2010-17550), and myBigData (TIN2010-17060) projects. We would like to kindly thank all W3C RDB2RDF Working Group members.