Mapping between Relational Database Schema and OWL Ontology

for Deep Annotation

Zhuoming Xu Shichao Zhang Yisheng Dong

College of Computer &
Information Engineering,
Hohai University,
Nanjing 210098, China
zmxu@hhu.edu.cn
Faculty of Information
Technology,
University of Technology,
Sydney, Australia
zhangsc@it.uts.edu.au
School of Computer
Science & Engineering,
Southeast University,
Nanjing 210096, China
ysdong@seu.edu.cn

Abstract the underlying database of the dynamic Web site.

Creating mappings between database schema and
Web ontology is a preconditioning process in the
generation of ontological annotations for dynamic
Web page contents extracted from the database. In this
paper, a practical approach to creating mappings
between a relational database schema and an OWL
ontology is presented. The approach can automatically
construct the mappings by following a set of
predefined heuristic rules based on the conceptual
correspondences between the schema and the
ontology. This automatic mapping is implemented as
the core functionality in a prototype tool D2OMapper
that has some assistant functions to help the user
manually create and maintain the mappings. Case
studies show that the proposed approach is effective
and the produced mappings can be applied to semantic
annotation of database-based, dynamic Web pages.
1. Introduction
The Semantic Web [1] aims to create machine-
processable Web content attached well-defined formal
semantics in order to provide better machine assistance
for human users in tasks. Semantically annotating Web
pages with Web ontologies is a key enabling
technology for achieving the goal. However, existing
tools can only produce semantic annotations for static
Web pages and how to annotate dynamic Web pages
that are generated from the underlying databases (the
greater majority of current Web content [2]) when the
clients request the pages is still an open problem [3, 4].
This problem has been referred to as deep annotation
[5, 6] that means the process of creating ontological
instances for the database-based, dynamic contents by
reaching out to the ‘deep Web’ and directly annotating
We agree to the idea that the database (i.e., Web
site) owner should cooperatively participate in deep
annotation [5, 6]. Furthermore, we argue that a
conventional dynamic Web site system can be
extended to automatically generate semantic
annotations for the dynamic contents by integrating the
following components into the system:
• A Web ontology that captures the knowledge from
the domain of discourse (DOD) of the relational
database underlying the Web site;
• A set of generic mappings between the database
schema and the ontology that map the implicit
semantics of the schema to the explicit and formal
knowledge structure of the ontology;
• A universal algorithmic procedure invoked by the
dynamic page scripts and executed by the Web
server when responding to page requests, which can
produce ontological instances that semantically
describe the database query results contained in the
pages based on the schema-to-ontology mappings.
Based on the above ideas, we have implemented a
prototype framework called DPAnnotator by extending
a conventional dynamic Web site. In the framework,
the Web ontology is obtained by translating the ER
schema of the relational database into an OWL
ontology with our self-developed tool ER2WO [7].
Limited by space, this paper addresses the issues
regarding the second component: Given a relational
database schema and an OWL ontology − both of them
have the same DOD and, optionally, are directly
derived from the same ER schema, how generic
mappings between them can be created and
represented to effectively support the semantic
annotation of database-based, dynamic Web pages?
The remainder of the paper is organized as follows.

Proceedings of the 2006 IEEE/WIC/ACM International Conference

on Web Intelligence (WI 2006 Main Conference Proceedings)(WI'06)
0-7695-2747-7/06 $20.00 © 2006
 Sect. 2 briefly discusses related work. In Sect. 3 we
present our mapping approach. Our prototype mapping
tool D2OMapper and a typical mapping example are
given in Sect. 4. Last section concludes the work.
2. Related Work
Focusing on exposing an RDF description of SQL-
query results, the D2R MAP tool (www.wiwiss.fu-
berlin.de/suhl/bizer/d2rmap/D2Rmap.htm) employs a
declarative language to describe mappings from a
specific SQL-query to ontological entities to be
created. The mappings can later be executed by the
D2R processor to create lightweight ontological
instances in a RDF file. However, the definition
process is task-centric and fully-manual, and the
produced mappings are simple and query-specific
hence do not fully model the natural concepts and
relations that the relational description is attempting to
capture. The work by Handschuh, et al. [5, 6] is the
first to introduce the idea of deep annotation. They
developed a prototype framework for “mapping and
migrating legacy (relational) data to the Semantic
Web” by exploiting server-side Web page markup,
client-side annotation and schema-to-ontology
mapping, where a prototype tool called OntoMat-
Reverse was used to map relational schema elements to
ontology entities. Although the focus and goal of their
work is different comparing to our research, the work
gives us good hints for developing a more formal and
automatic approach to creating generic mappings
between relational database schema and OWL [8]
ontology.
3. Proposed mapping approach
3.1. Mapping source and target
As the mapping source, a relational database
schema can be derived from an ER schema of the
database with an existing modeling tool such as
PowerDesigner by following the classical “ER-to-
relational conversion” rules. In Definition 1 we assume
without loss of generality that all relations in the
schema are in 3NF.
Definition 1. A relational database schema is a tuple
D = ( N , col, datatype, pk, fk, assoc, subof) , where
• N is a finite name set partitioned into: (1) a subset
ET of entity table names; each entity table contains
rows of instance data describing entities in the real
world, (2) a subset RT of relationship table names;
each relationship table contains rows of instance
data describing the relationships between entities,
Proceedings of the 2006 IEEE/WIC/ACM International Conference
on Web Intelligence (WI 2006 Main Conference Proceedings)(WI'06)
0-7695-2747-7/06 $20.00 © 2006
and (3) a subset DT of datatype names; each
datatype is a predefined RDBMS datatype,
specifying a value range of the relevant instance
data. Furthermore, for each t ∈ ET ∪ RT , there is a
finite nonempty set col(t ) of column names; each
c ∈ col(t ) has an associated datatype, denoted
datatype( c ) ∈ DT .
• For each t ∈ ET ∪ RT , there is exactly one primary
key pk(t ) whose values uniquely determine each
row of the instance data in t , where either
pk(t ) ∈ col(t ) (in this case pk(t ) is a single-
attribute key and t is an entity table) or
pk(t ) ⊆ col(t ) (in this case pk(t ) is a composite key
with more than one attribute, and t is a relationship
table).
• For each t ∈ ET ∪ RT , there are n ( n ≥ 0) foreign
keys fk(t , r ) where r ∈ ET ; each fk(t , r ) ∈ col(t )
references the values of the single-attribute primary
key of entity table r , and it holds that
value(fk(t , r )) ⊆ value(pk( r )) ∪ {null} where
value(*) denotes the value range of ‘ * ’ and
pk( r ) ∈ col( r ) .
• assoc ⊆ RT × ET × ET is a ternary relation over
RT and ET that models an association relation
between one relationship table and two entity tables
(we assume without loss of generality that n-nary
( n ≥ 3 ) relationships don’t exist in the ER schema).
For some t ∈ RT and r , s ∈ ET , assoc(t , r, s ) is
satisfied iif ∃fk(t , r ), fk(t , s ) ∈ col(t ) such that
pk(t ) = {fk(t , r ), fk(t , s )} ⊆ col(t ) .
• subof ⊆ ET × ET is a binary relation over ET that
models an inheritance relation between two entity
tables. For some t , r ∈ ET , subof(t , r ) is satisfied
iif ∃fk(t , r ) ∈ col(t ) such that either fk(t , r ) = pk(t )
(single inheritance) or fk(t , r ) ∈ pk(t ) (multiple
inheritance). Here t is a subentity table, r is a
superentity table, and all the related tables form a
generalization hierarchy of entity tables.
As the mapping target, an OWL ontology that can
also be derived from the database’s ER schema with
our ER2WO tool [7], consists of a set of axioms built
using OWL identifiers (each identifier is a URI
reference consisting of a namespace and a fragment
identifier) and constructs. Definition 2 is a concise
definition of the OWL ontology.
Definition 2. An OWL ontology is a tuple
O = ( ID, Axiom ) , where
• ID is a finite OWL identifier set partitioned into: (1)
 a subset CID of class identifiers including user-
defined identifiers plus two predefined classes
owl:Thing and owl:Nothing; classes are either
entity classes describing entities or relationship
classes describing the relationships between entities,
(2) a subset DRID of data range identifiers; data
range identifiers are predefined XML Schema
datatypes such as xsd:integer, (3) a subset
OPID of object property identifiers; object
properties link individuals (i.e., entities) to
individuals, and (4) a subset DPID of datatype
property identifiers; datatype properties link
individuals to data values.
• Axiom is a finite OWL axiom set partitioned into a
subset of class axioms and a subset of property
axioms; each axiom is formed by applying OWL
constructs to the identifiers or descriptions that are
the basic building blocks of a class axiom and
describe the class either by a class identifier or by
specifying the extension of an unnamed anonymous
class via the construct restriction.

Rule 1. Generation rule for entity table to entity class mapping.

For ∀t ∈ ET ∪ RT such that (¬ assoc(t , r, s )) ∧ ( r, s ∈ ET ) (actually, t ∈ ET ), if ∃ClassT = getName(t ) ∈ CID then
Mapping := ' EntityTable2EntityClassMapping' ; Source := t ; all Source. fk := fk(t, r ) = pk( r ) ; Source. pk := pk(t ) ; Target := ClassT .
Rule 2. Generation rule for non-foreign-key column to datatype property mapping.
For ∀c ∈ col(t ) such that ( c ≠ fk(t, r )) ∧ (t, r ∈ ET ) , if (∃dp = getName(c ) ∈ DPID ) ∧ (domain( dp ) = getName(t ) ∈ CID ) then
Mapping := 'Column2DatatypePropertyMapping' ; Source := c ; Source.datatype := datatype( c ) ; Target := dp ; Target.range := range( dp ) .
Rule 3. Generation rule for relationship table to relationship class mapping.
For ∀t ∈ ET ∪ RT such that assoc(t , r, s ) ∧ ( r, s ∈ ET ) (actually, t ∈ RT ),
if (∃ClassT = getName(t ) ∈ CID ) ∧ (∃ClassR = getName( r ) ∈ CID ) ∧ (∃ClassS = getName( s ) ∈ CID ) ∧
(∃opTR ∈ OPID ) ∧ (domain(opTR ) = ClassT ) ∧ (range(opTR ) = ClassR ) ∧
(∃opTS ∈ OPID ) ∧ (domain(opTS ) = ClassT ) ∧ (range(opTS ) = ClassS ) ∧
(∃opRT ∈ OPID ) ∧ (domain(opRT ) = ClassR ) ∧ (range(opRT ) = ClassT ) ∧
(∃opST ∈ OPID ) ∧ (domain(opST ) = ClassS ) ∧ (range(opST ) = ClassT )
then Mapping := ' RelationshipTable2RelationshipClassMapping' ; Source := t ; Source. fk1:= fk(t , r ) ; Source. fk 2 := fk(t , s ) ;
Source. pk := pk(t ) ; Target.RelationshipClass.ClassName := ClassT ; Target.RelationshipClass.ObjectPropertyToEntityClass1:= opTR ;
Target.RelationshipClass.ObjectPropertyToEntityClass 2 := opTS ; Target.EntityClass1.ClassName := ClassR ;
Target.EntityClass1.ObjectPropertyToRelationshipClass := opRT ; Target.EntityClass 2.ClassName := ClassS ;
Target.EntityClass 2.ObjectPropertyToRelationshipClass := opST .
Rule 4. Generation rule regarding the mapping of foreign-key to primary-key reference between two entity tables, where the
entity tables are not in a generalization hierarchy.
For ∀c ∈ col( r ) such that ( c = fk( r, s )) ∧ ( r, s ∈ ET ) ∧ (¬ subof( r, s )) ,
if (∃ClassR = getName( r ) ∈ CID ) ∧ (∃ClassS = getName( s ) ∈ CID ) ∧ (∃ClassT ∈ CID ) ∧
(∃opRT ∈ OPID ) ∧ (domain(opRT ) = ClassR ) ∧ (range(opRT ) = ClassT ) ∧
(∃opTR ∈ OPID ) ∧ (domain(opTR ) = ClassT ) ∧ (range(opTR ) = ClassR ) ∧
(∃opTS ∈ OPID ) ∧ (domain(opTS ) = ClassT ) ∧ (range(opTS ) = ClassS ) ∧
(∃opST ∈ OPID ) ∧ (domain(opST ) = ClassS ) ∧ (range(opST ) = ClassT )
then Mapping := ' FK2PKReferencesMapping' ; Mapping.type := 'Joining' ; Source. fk := fk( r, s ) ; Source. pk := pk( s ) ;
Target. EntityClass.ClassName := ClassR ; Target.EntityClass.ObjectPropertyToRelationshipClass := opRT ;
Target.RelationshipClass.ClassName := ClassT ; Target.RelationshipClass.ObjectPropertyToEntityClass := opTR ;
Target.RelationshipClass.ObjectPropertyToRelatedEntityClass := opTS ; Target.RelatedEntityClass.ClassName := ClassS ;
Target.RelatedEntityClass.ObjectPropertyToRelationshipClass := opST .
Rule 5. Generation rule regarding the mapping of foreign-key to primary-key reference between two entity tables, where the
entity tables are in a generalization hierarchy.
For ∀c ∈ col( r ) such that ( c = fk( r, s )) ∧ ( r, s ∈ ET ) ∧ subof( r, s ) , if (∃ClassR = getName( r ) ∈ CID ) ∧
(∃ClassS = getName( s ) ∈ CID ) ∧ (∃ subClassOf(ClassR ClassS ) or Class(ClassR partial ClassS ) ∈ Axiom)
then Mapping := ' FK2PKReferencesMapping' ; Mapping.type := ' Inheritance' ;
Source. fk := fk( r, s ) ; Source. pk := pk( s ) ; Target.Subclass := ClassR ; Target.Superclass := ClassS .

Figure 1. Heuristic rules for automatically creating schema-to-ontology mappings.

Proceedings of the 2006 IEEE/WIC/ACM International Conference

on Web Intelligence (WI 2006 Main Conference Proceedings)(WI'06)
0-7695-2747-7/06 $20.00 © 2006
 3.2. Automatic mapping rules
The rationale behind the automatic mapping is the
existence of conceptual correspondences between the
relational database schema and the OWL ontology,
both modeling the same domain of interest. To identify
these correspondences, we exploit schema matching
techniques [9] and combine syntactic matching with
semantic matching to determine both element-level and
structure-level correspondences between the schema
and the ontology.
Element correspondences (e.g., table-to-class,
column-to-property) can be determined by finding
naming matching between the pair of elements at the
same concept level using string-based techniques such
as same-prefix and the smallest edit distance
approaches [9]. If renaming trails (which record all the
renaming operations during the derivation of the
schema and/or the ontology from the ER schema) exist
in the system, naming matching can be directly
obtained by accessing the trails file and through simple
name equality. Optionally, all identified element
correspondences can be further confirmed by the
domain expert via man-machine conversation.
The determination of structure correspondences
relies on a semantics-based approach. By examining
the relations amongst schema/ontology elements,
structure matching between the schema and the
ontology are identified. Both the element and the
structure correspondences are mutually verified and
reinforced before the last determination. Based on
these correspondences, a set of heuristic rules for
automatically creating the schema-to-ontology
mappings can be specified. In Figure 1, we use a
generic 3-tuple ( Mapping , Source, Target ) to denote
each mapping definition item including the category,
source and target of a mapping, and use Source.Child
to denote the child element of the source and
Target.Child [.GrandChild ] to the child (grandchild)
element of the target. Additionally, three auxiliary
functions are used: getName( e) is for returning the
fragment identifier of an ontology class/property
corresponding to database table/column e via naming
matching (aided by man-machine conversation) or by
accessing the renaming trails, domain( p ) and
range( p ) are two functions for returning the domain
and range of property p in the ontology, respectively.
3.3. Mapping data representation
Due to the hierarchical and semi-structured natures
of the mapping definition data introduced earlier, we
Proceedings of the 2006 IEEE/WIC/ACM International Conference
on Web Intelligence (WI 2006 Main Conference Proceedings)(WI'06)
0-7695-2747-7/06 $20.00 © 2006
choose an XML format to represent the mapping data
and metadata (e.g., the DBMS, database name and
location, the ontology filename, namespace and
location) in a valid XML document. The data and
metadata are stored in separate XML elements. Each
mapping is represented with an XML element; the
source and target are subelements of the element; the
components of the source/target are subelements of the
subelements. Details of a mapping/source/target are
attached via some XML attributes to the elements.
4. Implementation and example
Following the proposed approach, we developed
D2OMapper tool based on J2SE v 1.4.2 and Jena2
API. The tool can take a relational database schema
and an OWL ontology (and a term renaming trails file
if necessary) as inputs and produce the mappings both
automatically (via automatic mapping) and semi-
automatically (via man-machine conversation). Case
studies with D2OMapper indicated the effectiveness of
our approach and the applicability of the produced
mappings to the semantic annotation of database-based
Web pages supported by our DPAnnotator framework.
Figure 2. An example ER schema univER.
Here we give an example to show the mapping
process in D2OMapper. Figure 2 is an ER diagram
univER created with PowerDesigner 9.5. From the ER
schema, a MySQL 4.0 database univ was generated
by PowerDesigner and an OWL ontology univOnt
was produced from ER2WO tool [7]. As a proof-of-
concept, renamings (e.g., Course -> course during
ER-to-relational conversion, and Graduate ->
GraduateStudent during ER-to-ontology translation)
were recorded in a trails file. Inputting the schema,
ontology and renaming trails file to D2OMapper and
performing the ‘automatic mapping’ process, the
automatically-generated mappings were saved to the
 XML document univ_Db2OntMappings.xml and
Figure 3. Screenshot of D2OMapper, where the database schema, the OWL ontology and the automatically-
generated mappings are displayed in the left, right and upper middle areas, respectively.
5. Conclusion
We have presented a practical approach for creating
generic mappings between relational database schema
and OWL ontology. Since full implementation of the
Semantic Web requires widespread availability of
ontological annotations for Web pages, our approach
and tool can act as a gap-bridge between existing
database applications and the Semantic Web.
Acknowledgements. This work was funded by the
Natural Science Foundation of Jiangsu Province of
China (BK2003001) and the Foreign Experts
Invitation Key-Project Foundation of the State
Administration of Foreign Experts Affairs of China
(20050360543).
Reference
[1] T. Berners-Lee, J. Hendler, O. Lassila, “The Semantic
Web”, Scientific American, Vol. 284, No. 5, 2001, pp. 34-43.
[2] K. C.-C. Chang, B. He, C. Li, et al., “Structured
databases on the Web: observations and implications”,
Proceedings of the 2006 IEEE/WIC/ACM International Conference
on Web Intelligence (WI 2006 Main Conference Proceedings)(WI'06)
0-7695-2747-7/06 $20.00 © 2006
displayed on the tool screen, as depicted in Figure 3.
SIGMOD Record, Vol. 33, No. 3, 2004, pp. 61-70.
[3] L. Reeve, H. Han, “Survey of semantic annotation
platforms”, Proc. of the 2005 ACM Symposium on Applied
Computing, ACM Press, 2005, pp. 1634-1638.
[4] V. R. Benjamins, J. Contreras, O. Corcho, et al., “Six
Challenges for the Semantic Web”, AIS SIGSEMIS Bulletin,
Vol. 1, No. 1, 2004, pp. 24-25.
[5] R. Volz, S. Handschuh, S. Staab, et al., “Unveiling the
hidden bride: deep annotation for mapping and migrating
legacy data to the Semantic Web”, Journal of Web Semantics,
Vol. 1, No. 2, 2004, pp. 187-206.
[6] S. Handschuh, S. Staab, R. Volz. “On deep annotation”,
Proc. of the 12th Int’l World Wide Web Conf., ACM Press,
2003, pp. 431-438.
[7] Z. Xu, X. Cao, Y. Dong, et al., “Formal approach and
automated tool for translating ER schemata into OWL
ontologies”, Advances in Knowledge Discovery and Data
Mining, LNAI 3056, Springer, 2004, pp. 464-475.
[8] M. Dean, G. Schreiber (eds.): OWL Web Ontology
Language Reference, W3C Recommendation, 10 Feb 2004.
http://www.w3.org/TR/owl-ref/.
[9] P. Shvaiko, J. Euzenat, “A survey of schema-based
matching approaches”, Journal on Data Semantics, Vol. 4,
2005, pp. 146-171.