RDB2RDF: Completed Transformation from Relational
Database into RDF Ontology
Pham Thi Thu Thuy Nguyen Duc Thuan
Faculty of Information Faculty of Information
Technology Technology
Nha Trang University Nha Trang University
Vietnam Vietnam
thuthuypht@gmail.com ngducthuan@gmail.com ykhan@khu.ac.kr kspark@khu.ac.kr yklee@khu.ac.kr
ABSTRACT
One of the most advantages of the Semantic Web is to augment
the data with a well-defined meaning and linking between data by
using the RDF ontology language. Today most of data are stored
in relational databases. In order to reuse and infer this data on the
Semantic Web, there is a need for converting the data stored in
relational databases to the form of RDF. Some approaches have
been proposed, however, most of them transform a single table
into RDF triples. This paper presents RDB2RDF, a complete
method to transform all tables in the relational database into RDF
ontology. The transformation makes it possible to reverse RDF
ontology to relational tables. Most of all, all the steps in
RDB2RDF are done automatically without any user intervention.
Categories and Subject Descriptors
I.2.4 [Knowledge Representation Formalisms and Method]:
Representation languages. I.5.3. [Clustering] Similarity
measures.
General Terms
Standardization, Languages.
Keywords
Semantic Web, relational databases, RDF, transformation.
1. INTRODUCTION
The Semantic Web is an extension of the current Web, in
which data are augmented with a well-defined meaning and
relationship between data by using RDF (Resource
Description Language) with the vocabulary supported by
RDF Schema (RDFS). Those RDF data can be understood
by the computer and then can be shared, exchanged or
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies
are not made or distributed for profit or commercial advantage and that
copies bear this notice and the full citation on the first page. To copy
otherwise, or republish, to post on servers or to redistribute to lists,
requires prior specific permission and/or a fee.
IMCOM (ICUIMC)’14, January 9–11, 2014, Siem Reap, Cambodia.
Copyright 2014 ACM 978-1-4503-2644-5 …$15.00.
Yongkoo Han Kisung Park Young-Koo Lee
Kyung Hee Kyung Hee Kyung Hee
University University University
South of Korea South of Korea South of Korea
integrated into a data repository enabling applications to
use the data in different contexts [7].
RDF data can be presented in the form of triple (Subject -
Predicate – Object) or RDF/XML which stores RDF format
in the form of XML file [5]. The most advantage of
RDF/XML is that it can reuse the existing XML tools.
Moreover, each RDF format has an internet content type
[5], passed by the server, so the client knows how to parse
the data. Therefore, in this paper we use RDF/XML format
to store the results.
Moreover, most of formatted data today is stored in
relational databases which are excellent tools for storing
and querying data, but lack the ability to describe the
semantics of data. In order to utilize the relational data in a
semantic context, we should transform those data into RDF,
the data format of the Semantic Web. There are some
proposals that move relational data to the RDF dataset. The
typical approaches are proposed by Edgard Marx et al. [4],
Huajun Chen et al. [6], and Kate Byrne [9]. However, most
of proposed approaches are simple and equivalent
matching. They map some tuples of relational data to some
triples of RDF dataset without considering the RDFS
semantic constraints and the complex query to extract
important information.
The main goal of RDB2RDF is to allow flexible mappings
of complex relational structures into RDF ontology without
changing the existing database. The flexibility is achieved
by employing SQL statements directly in the
transformation steps. The resulting record sets are grouped
afterwards and the data is mapped to the RDF triples.
Our contributions are as three folds:
x RDB2RDF can transform all tables in the
relational database into RDF ontology.
x The transformation keeps the tracks of attribute
keys in the tables so that the algorithm can be
extended to reverse RDF ontology to relational
tables.
x All the steps in RDB2RDF are done automatically
without any user intervention.
The rest of the paper is organized as follows. Section 2 an entity in the conceptual data model. We can check this
presents some specific methods of the related work. In the requirement by looking in the table. Are there attributes
Section 3, we describe the RDB2RDF architecture and which are primary keys and are not foreign keys? If yes,
details of each steps. Section 4 presents the illustrating this table is generated from an entity. Otherwise, it is from a
example for the RDB2RDF. The evaluation is presented in relationship. The target of the transformation is a RDF file
Section 5. Finally, Section 6 summarizes the paper and which has the name of the source table (with different
mentions to the future research. extension).
The extracted table must have at least one attribute which is
2. RELATED WORK a primary key. This primary key is used to create URI for
the resource. Each extracted attribute has domain and range
There are many approaches investigating the as describing in Table 1.
transformation of the relational database into a RDF
dataset. The most similar approach to our approach is the Table 1. Domain and range for each extracted attribute
D2R [3]. However, this approach only extracts interest
Attribute type Domain Range Description
attributes in tables and then transform them into RDF
triples. Our proposed method transforms all attributes in a Primary key in Name of Name of primary
primaryKey
primary table primary table table
database.
Foreign key in Name of Name of
foreignKey
More work has been addressed on the issue of explicitly primary table primary table referenced table
defining semantics in database schemas [2], [13], extracting Name of table
Primary key in Name of
semantics out of database schema and transforming a containing this primaryKey
other table primary table
relational model into an object-oriented model [1], which is key
close to an ontological theory. Foreign key in Name of Name of
foreignKey
other table primary table referenced table
Other well-known approaches are RDB2RDF [4], Juan Nomal Name of
Name of
Sequeda [8], Huajun Chen et al. [6], and Kate Byrne [9]. attribute (not datatype (in attribute
primary table
RDB2RDF [4] method uses the mapping language R2RML key) XML Schema)
[15] to convert tuples of the relational data to RDF triples.
However, this is the direct mapping which does not 3.2 RDB2RDF architecture
consider the RDFS semantic constraints such as
rdfs:subClassof, rdfs:subPropertyof, rdfs:domain, and The details of our approach is presented in Figure 1.
rdfs:range. Juan Sequeda [8] and Huajun Chen et al. [6] are
also direct mappings by using RDF query and SPARQL
query, respectively, to extract some specific information Description RDFS
of attributes RDF
from the relational data. Kate Byrne [9] defines new RDF 1 in DB 3.2 5.2
relationships and maps cultural heritage data to those
relationships.
In the broader sense, our approach could be treated as the Database 3.1 5.1
reverse method: RDF storage in relational database.
Agrawal et al. [12] use only one “universal” table in the 2
database. Every individual (instance) falls into one record 4 XML
Select query Attributes
in the table. While the data model is simple, this approach Execute
Select
has some drawbacks such as large number of columns and query
limits on property values. The “Generic Representation”
[14] has a single table where each record corresponds to a
RDF triple. However, this design means that any query has Figure 1. RDB2RDF architecture
to search the whole database and queries that involve joins. As shown in Figure 1, our approach has five small steps as
The cost will be especially expensive. following:
x Step 1: Describe all attributes in a database. The
3. THE RDB2RDF DESCRIPTION AND
description result is a text file stored in secondary
PROCESS memory.
x Step 2: Use SELECT command to extract the data
3.1 RDB2RDF description describing the resource. Each resource should
. belong to a primary table. The attributes of the
The source of the transformation should be a primary table primary table must be extracted first.
in a relational database. This table has to be generated from
 x Step 3: Generate RDF Schema (RDFS) file based
on the description file (Step 1) and the attributes
extracted from Step 2.
x Step 4: Execute the SELECT query to extract
instances in the relational database. The results are
stored in XML format.
x Step 5: Generate RDF dataset from RDFS and
XML files.
Details of each step are presented in next sections.
3.3 SELECT syntax for extracting data
The SELECT command must contain the primary key of
the primary table. This primary key is considered as URI
for instances in the resource. The SELECT syntax is as
following:
SELECT tableName.ID, attibute1 As AliasName1, attibute2
As AliasName2....
FROM tableName , table2Name ....
WHERE .....
FOR XML AUTO, ELEMENTS ODER BY tableNameID
We note that the attribute key in the primary table must be
extracted in the SELECT command.
3.4 Generating RDFS
We assume that the extraction of data in the relational
database is not redundant. It means that if the foreign key is
extracted, the primary key which is referenced by the
foreign key is not extracted and vice versa. The RDFS file
contains the classes and properties which are described as
following:
x Description of classes: Each table in a database is
transformed into a class. The description of a class
is based on the key attribute (primary key or
foreign key). The class name is a value in the
range column. If the parent class contains values,
the class in the range column is a child class of a
parent class.
x Description of properties: The domain of all the
attributes is the name of primary table. The range
of attributes is the values from the range column.
3.5 Generating RDF
This step produces a RDF file from the XML and RDFS
files generated in Section 3.3 and 3.4. The SELECT
command to generate RDF format in the form of XML file
is as following:
SELECT property1, property2.....
FROM table1, table2, ....
WHERE [Where conditions]
ORDER BY property1
FOR XML AUTO, ELEMENTS
where property1 is the attribute key in the primary table;
table1 is the name of primary table.
The algorithm to generate RDF/XML file can be described
as following pseudo codes:
Algorithm 1. GenerateRDF
༦Input: a XML file Fxml, a primary table Tp, a RDFS file
Fs
༦Output: a RDF file F
1: Collect all the children elements of the root element in
the XML file Fxml.
2: FOR each child element ec in Fxml.
3: read the value ID of the attribute key in the Tp
4: create a resource having
URI=baseURI+ResourceName+#+ID.
5: FOR each property p in Fs
6: take a list of elements (listEle) in an instance.
7: IF n(|listEle|) > 0 THEN
8: FOR each child element ec in listEle
9: IF is the attribute key THEN
10: Create a corresponding property
11: Generate a property having ec’s value.
12: Append predicate to the resource.
10. RETURN F
We describe an algorithm for generating a RDF file from
the primary table, the RDFS file and the XML file
generated by Algorithm 1. First, we collect all the children
elements of the root element in XML file (line 1). Second,
we read the value ID of the attribute key in the primary
table, and then we iteratively create a resource having an
URI that includes base URI and Resource Name and ID for
each child element in the XML file (line 2-4). Third, we
take a list of elements (listEle) in an instance for each
property (line 6). If the number of elements in listEle is
greater than 0 and the property is the attribute value, we
create a corresponding property which referenced to the
resource having URI for each property (line 7-10). We
generate property which value is the value of element child
in listEle, and then we put predicate between containers
(line 11). Finally, we append predicate to the resource. If all
the properties in RDFS are not traveled, we return to the
attribute key checking step (line 12). Through these all step,
we can get the results RDF file.
4. ILLUSTRATING EXAMPLE
The following example illustrates the use of RDB2RDF to Document.DocumentID #Document #Document primaryKey
transform data about authors and their documents from a For easy understanding, we can replace the attribute
database into RDF. Because authors usually have more than Doc_Author.Author by the alias name “Created_By”.
one document and documents can be created by multiple
authors, the information can be stored in three database The RDFS file that stores the required information is
tables: one for the authors, one for their documents, and the generated as following:
third one for the n:m relationship between authors and <?xml version="1.0" ?>
documents:
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-
Author (AuthorID, AuthorName, AuthorEmail, syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-
AuthorORG) schema#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#">
Document (DocumentID, DocName, DocFormat, DocLink)
<rdfs:Class rdf:ID="Document" />
Doc_Author (AuthorID, DocumentID).
<rdfs:Class rdf:ID="Author" />
The instances of three above tables are as following:
<rdf:Property rdf:ID="DocName">
Author: <rdfs:domain rdf:resource="#Document" />
AuthorID AuthorName AuthorEmail AuthorORG <rdfs:range rdf:resource="&rdf;Literal" />
</rdf:Property>
Author01 Anderson anv@yahoo.com MinhKhaiPub
<rdf:Property rdf:ID="DocFormat">
Author02 Thomas btv@yahoo.com MinhKhaiPub <rdfs:domain rdf:resource="#Document" />
<rdfs:range rdf:resource="&rdf;Literal" />
Document: </rdf:Property>
<rdf:Property rdf:ID="DocLink">
DocumentID DocName DocFormat DocLink
<rdfs:domain rdf:resource="#Document" />
Doc01 C++ pdf http://www.somewh
programming ere/Doc <rdfs:range rdf:resource="&rdf;Literal" />
Doc02 Semantic Web chm http://www.somewh </rdf:Property>
ere/Doc <rdf:Property rdf:ID="Created_By">
Doc03 MSSQL 2000 pdf http://www.somewh <rdfs:domain rdf:resource="#Document" />
ere/Doc
<rdfs:range rdf:resource="#Author" />
Doc04 ASP & pdf http://www.somewh
</rdf:Property>
ASP.NET ere/Doc
</rdf:RDF>
Doc_Author: To create the RDF file, we use the following SELECT
AuthorID DocumentID
command.
Author01 Doc01 SELECT DocID AS [Document_RESOURCEURI_], DocName,
DocFormat, DocLink, AuthorID AS [Created_By]
Author02 Doc01
FROM Document, Doc_Author
Author01 Doc02
WHERE Document.DocID=Doc_Author.DocID
Author01 Doc03
ORDER BY DocID
Author02 Doc04
FOR XML AUTO, ELEMENTS
The result RDF/XML file is below:
For example, we would like to know the detail information <?xml version="1.0"?>
about the author. The extracted information is as following:
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
Attribute xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
Attribute name domain range
type
xmlns:res="http://www.oracle.com/technology/pub/articles/res#"
Author.AuthorID #Author #Author primaryKey
xmlns:db="http://http://www.w3.org/2001/XMLSchema-
Author.AuthorName #Author Literal Attribute instance/mine#">
Author.AuthorEmail #Author Literal Attribute <db:result> <db:Document>
Author.AuthorORG #Author Literal Attribute <db:Document_RESOURCEURI_>
 Doc01</db:Document_RESOURCEURI_>
<db:DocName> C++ Programming</db:DocName>
<db:DocFormat>pdf</db:DocFormat>
<db:DocLink>
http://www.somewhere/Doc </db:DocLink>
<db:Doc_Author>
<db:Created_By> Author01</db:Created_By>
</db:Doc_Author>
<db:Doc_Author>
<db:Created_By> Author02</db:Created_By>
</db:Doc_Author>
</db:Document>
<db:Document>
<db:Document_RESOURCEURI_>
Doc02</db:Document_RESOURCEURI_>
<db:DocName>Semantic Web</db:DocName>
<db:DocFormat>chm</db:DocFormat>
<db:DocLink>http://www.somewhere/Doc
</db:DocLink>
<db:Doc_Author>
<db:Created_By> Author01</db:Created_By>
</db:Doc_Author>
</db:Document>
<db:Document>
<db:Document_RESOURCEURI_>
Doc03</db:Document_RESOURCEURI_>
<db:DocName>MSSQL 2000</db:DocName>
<db:DocFormat>pdf</db:DocFormat>
<db:DocLink> http://www.somewhere/Doc
</db:DocLink>
<db:Doc_Author>
<db:Created_By> Author01</db:Created_By>
</db:Doc_Author>
</db:Document>
<db:Document>
<db:Document_RESOURCEURI_>
Doc04</db:Document_RESOURCEURI_>
<db:DocName> ASP and ASP.NET</db:DocName>
<db:DocFormat>chm</db:DocFormat>
<db:DocLink> http://www.somewhere/Doc
</db:DocLink>
<db:Doc_Author>
<db:Created_By> Author02</db:Created_By>
</db:Doc_Author>
</db:Document>
</db:result>
</rdf:RDF>
The RDB2RDF allows to transform an arbitrary relational
database into RDF formats which includes RDF Schema
file (*.rdfs) and RDF file (*.rdf). The RDF Schema file
describes classes and the relationship between properties
and classes. The RDF file stores all instances of relational
database. The transformation does not depend on the
database and does not make any change on the database.
RDB2RDF is implemented by using the C# language with
the support of the library .Net 2.0. The relational databases
are stored in SQL server 2012. Therefore, before executing
the transformation, we must connect to the SQL database.
Our program supports two authentication (windows and
server) for connecting to the database.
Our RDB2RDF program provides two kinds of
transformations. The first one allows users to use the button
to convert all relational tables into RDF ontology. The
second one let users enter the SQL commands to specify the
needed information from some tables. All steps in
RDB2RDF program are automated and thus inexpensive
and fast.
5. EVALUATION
We evaluate the proposed transforming strategies by
matching a relational database with a RDF file to determine
the true matches, and compare our results with related
methods. To assess the quality of the matching system, we
use precision and recall [16]. Given the set of expected
matching pairs, R, (produced by a human), the set of
alignment pairs, T, (produced by the matching system for
the proposed methods), the Precision is computed as the
following equation:
R ˆT (1)
precision(R,T)
T
Recall specifies the share of real correspondences:
R ˆT (2)
recall(R,T)
R
Although precision and recall are the most widely used
measures, when comparing matching systems, one may
prefer to have only a single measure. For this reason, F-
measure [16], is introduced to aggregate the precision and
recall.
(3)
precision* recall
F  measure 2*
precision+ recall
To obtain practical evidence, we applied our transformation
to two sample databases produced by Microsoft,
particularly, Northwind [10], and Pubs [11].
We compare the precision, recall, and F-measure values
between our proposed method and the most related work,
such as D2R [3], RDB2RDF [4], Juan Sequeda [8], and
Huajun Chen et al. [6]. The matching system is also
implemented by using Visual C#. The comparing results are
shown in the following figures.
Figure 2. Matching comparison between our method and
related work on Northwind database
Figure 3. Matching comparison between our method and
related work on Pub sample database
Figure 2 and Figure 3 show that our matching quality is
highest in comparing to those of the related work.
RDB2RDF [4] is ranked second, then J. Sequeda [8], H.
Chen et al. [6], and D2R [3]. The main reason is that our
method and RDB2RDF [4] transform all relational data into
RDF whereas other three methods extract some relational
tuples. Moreover, our method maintains the relationships
between foreign key and primary key among relations
whereas RDB2RDF [4] does not. Among D2R [3], J.
Sequeda [8], and H. Chen et al. [6] methods, J. Sequeda [8]
gives the highest matching values since this method retains
the connections between foreign keys and primary keys.
Moreover, when extracting some portions of the relational
data, those three methods change some of the data structure
so that their matching scores are not good.
There are some small differences between Figure 2 and
Figure 3, since the differences of Northwind and Pubs
databases. Northwind database has 13 relations in
comparing to 11 relations in Pubs database. Among those
relations, there are relationships between foreign keys and
primary keys. In this experiment, the total number of the
relationships in the Northwind database is higher than that
of Pubs database. Therefore, for those methods which do
not maintain the foreign key and primary key relationship,
their matching results in the Northwind database are lower
than those in the Pubs database. For instance, the D2R’s F-
measure score in the Figure 2 is only 58% compared with
66% in the Figure 3.
6. CONLUSIONS
Transformation from relational database into RDF ontology
plays a critical role in realizing the Semantic Web as well
as in many data sharing problems. There are many
approaches mentioning this transformation. Moreover, most
of those approaches directly transform relational tuples into
RDF triples without keeping the foreign key and primary
key relationships. Other methods transform some relational
tuples into the RDF triples and do not consider the RDFS
semantic constraints and relational data’s structure. Our
proposed RDB2RDF method can transform all data from
the relations or can extract any required information while
keeping the relationship between primary keys and foreign
keys and improve the relational data semantics by using
RDFS vocabularies. The experimental results show that our
proposed method outperforms other related work due to
these reasons.
Moreover, all the steps in our proposed method can be
executed automatically without any human intervention.
This algorithm can be also implemented as an intermediate
module between any relational database and Semantic Web
page. The extracted information can be selected by the
users. Our future direction is to transform relational
databases into OWL ontology which supports more
semantics for the data than RDF.
7. ACKNOWLEDGMENTS
This research was supported by the MSIP (Ministry of Science,
ICT & Future Planning), Korea, under the ITRC (Information
Technology Research Center) support program supervised by the
NIPA (National IT Industry Promotion Agency) (NIPA-2013-
(H0301-13-2001))
8. REFERENCES
[1] Behm A., Geppert A., Dittrich, K. 1997. On the Migration of
Relational Schemas and Data to Object-Oriented Database
Systems. In Proceeding of the 5th Int. Conference on Re-
Technologies for Information Systems (Klagenfurt,
December 1997), pp. 13-33.
[2] Chiang R., Barron T., Storey V. 1994. Reverse engineering
of relational databases: Extraction of an EER model from a
relational database. Journal. of Data and Knowledge
Engineering, Vol. 12, No. 2, pp. 107–142.
[3] Christian Bizer. 2003. D2R Map - A Database to RDF
Mapping Language. WWW 2003, Hungary.
[4] Edgard Marx, Percy Salas, Karin Breitman, José Viterbo,
Marco A. Casanova. 2013. RDB2RDF: A relational to RDF
 plug-in for Eclipse. Software. Practice Expert, Vol. 43, No. [10] Microsoft. 2011. Northwind database.
4, pp. 435-447, doi:10.1002/spe.2145 http://northwinddatabase.codeplex.com/
[5] Graham Klyne, Jeremy Carroll. 2002. Resource Description [11] Microsoft. 2013. Pubs sample database.
Framework (RDF): Concepts and Abstract Syntax. W3C http://technet.microsoft.com/en-
Working Draft (work in progress). us/library/aa238305%28v=sql.80%29.aspx.
http://www.w3.org/TR/2002/WD-rdf-concepts-20021108/. [12] R. Agrawal, A. Somani, and Y. Xu. 2001. Storage and
[6] Huajun Chen, Zhaohui Wu, Heng Wang and Yuxin Mao. Querying of E-Commerce Data. In Proceedings of VLDB.
2006. RDF/RDFS-based relational database integration. In [13] Rishe N. 1992. Database Design: The Semantic Modeling
Proceedings of the 22nd International Conference on Data Approach. McGraw-Hill.
Engineering. pp. 94-104.
[14] S. Alexaki, V. Christophides, G. Karvounarakis, D.
[7] James Hendler, Tim Berners-Lee, Eric Miller. 2002. Plexousakis & K.Tolle, 2001. On Storing Voluminous RDF
Integrating Applications on the Semantic Web. Journal of Description: The case of Web Portal Catalogs, In Proc. of
the Institute of Electrical Engineers of Japan, Vol 122(10), WebDB2001 in conjunction with ACM SIGMOD'01
p.676-680. Conference.
[8] Juan Sequeda, Marcelo Arenas, Daniel P. Miranker. 2012. [15] W3C. 2012. R2RML: RDB to RDF mapping language.
On directly mapping relational databases to RDF and OWL. http://www.w3.org/TR/r2rml/
WWW 2012, 649-658
[16] Wikipedia, “Precision and recall”,
[9] Kate Byrne. 2006. Tethering cultural data with RDF. In http://en.wikipedia.org/wiki/Precision_and_recall
Proceedings of the Jena user conference 2006 (JUC2006),
UK.