We demonstrate a high-level RDB2OWL language for database-toontology mapping specification in a compact notation within the ontology class and property annotations, as well as a corresponding mapping implementation tool that translates the RDB2OWL mappings into executable D2RQ mappings thus allowing to create a semantic SPARQL endpoint containing conceptually organized data from a relational database.
Exposing the contents of relational databases (RDB) to semantic web standard RDF
[
The technical task of mapping relational databases to RDF/OWL formats is
nowadays well understood and widely studied, just to mention D2RQ [
The central novel point of this demonstration is a tool implementing the RDB2OWL notation2 via converting a RDB2OWL mapping into an executable D2RQ mapping that can further on be used by the D2RQ platform either to produce the RDF dump of the source RDB, or to turn it into a SPARQL endpoint. Alternative RDB2OWL implementations sharing the inner RDB2OWL mapping representation with the translation into D2RQ are underway.
A particular usage scenario for RDB2OWL mappings is a semantic re-engineering
of existing relational databases (cf. e.g. [
Note that a textual RDB2OWL mapping specification can be used also as a reference for a (legacy) RDB by documenting the structure of the data contained therein. 2
A RDB2OWL mapping defines the correspondence between a relational database and an OWL ontology or RDF schema. The mapping information consists of elementary mappings or maps that are recorded in annotation assertions for ontology entities3 class maps for ontology classes, data property maps and object property maps for ontology data properties and object properties respectively.
The general pattern of class map as well as object and data property map definition follow the common sense structural principle of mapping ontology classes to database tables, data properties to table columns and object properties to links between tables.
More precisely, a class map in RDB2OWL is characterized by a table expression, possibly involving a join of several tables and a filter, and a pattern for instance resource URI construction from a table expression row. A class map can be attached to a single ontology/schema class, meaning that it describes instances for this class.
An object property map contains references to its subject (source) and object (target) class maps in the property map’s (extended) table expression structure; such references bring the class map table expressions as components into the property map’s table expression and provide the patterns of the property triple subject resp. 2 The tool is freely available for download from http://rdb2owl.lumii.lv/ 3 We use rdb2owl:DBExpr as the annotation property, where
rdb2owl:=<http://rdb2owl.lumii.lv/2012/1.0/rdb2owl#> object URI generation from the property map’s table expression row. An object property map is always attached to a single object property within the ontology.
Similarly, a data property map is characterized by a corresponding (extended) table expression that contains a reference to the property map’s subject (source) class map, and a value expression describing the computation of the property literal value that corresponds to the URI, as computed by the subject class map’s URI pattern. A data property map is always attached to a single data property within the ontology.
The textual form of RDB2OWL maps relies on textual presentations of table expressions, instance URI generation patterns and expression values; it is optimized to take into account the available ontology and RDB schema context information. Thing {disjoint}
DBExpr{rdb2owl}
AcademicProgram enrolled 1 {DB: XProgram} {DB: ->} programName:string{{DB: Name}} {DB: =>} includes
Course takes {<>teaches} {DB: XCourse} {DB: =>Registration: courseName:string{{DB: Name}} (DatePaid is not null)->} courseCode:string{{DB: Code}} teaches {<>takes} courseCredits:(integer [>0]){{DB:
{DB: ->} Credits}} course 1 courseExtInfo:string{{DB: {DB: ->} buildExtInfo(Code,Credits)}}
Nationality {DB: Nationality} nCode:string{{DB: Code}} nValue:string{{DB: Value}}
FacultyLevel {DB: Teacher_Level {uri=('Level_', Level_Code)}} acadTitle:string{{DB: Level_Code}}
Person personName:string personID:string{{DB: [[Student]].IDCode},{DB: [[Teacher]].IDCode}} nationality:Nationality{{DB: [[Student]]->},{DB: [[Teacher]]->}}
Student {DB: XStudent} studentName:string{<personName}{{DB: Name}} studentNumber:string{{DB: StudNumber}}
Teacher studen1t {DB: ->} {DB: XTeacher} teacherName:string{<personName}{{DB: Name}} salary:(decimal [>0]){{DB: Salary}} facultyLevel:FacultyLevel{{DB: ->}}
Professor =Teacher and facultyLevel value Level_Professor {DB: [[Teacher]];Level_Code='Professor'} {disjoint}
Assistant =Teacher and facultyLevel value Level_Assistant {DB: [[Teacher]];Level_Code='Assistant'}
Registration {DB: Registration} datePaid:dateTime{{DB: DatePaid}}
CompletedRegistration {DB: [[Registration]] ?Out} dateCompleted:dateTime{{DB: DateCompleted}} mark:(integer [>=0, <=10]){{DB: MarkReceived}}
{disjoint}
OptionalCourse
{DB: [[Course]];
Required=0}
MandatoryCourse
{DB: [[Course]];
Required=1}
In what follows, we outline the concrete syntax of RDB2OWL maps. Figure 1
contains an illustrative example of a mini-University OWL ontology in OWLGrEd4
ontology editor notation [
There is a further possibility of local filter introduction in navigation expressions, such as XStudent=>Registration:(DatePaid is not null)->XCourse.
The textual syntax for a class map consists of table expression and URI pattern specification, such as ‘Teacher_Level {uri=('Level_', Level_Code)}’; the URI pattern is expected to have a list of constant strings and column expressions whose values are concatenated to give the local name of the corresponding ontology class instance. The URI pattern can be omitted, if it is formed just from table expression’s leftmost table name followed by its primary key column(s) value. A class map’s table expression can refer also to a defined class map either by its explicit name, or by the name of the class for which it is the sole class map (e.g. [[Teacher]]).
The object property map is described as an extended table expression where two sub-expressions denote its subject (source) and object (target) class maps respectively. These sub-expressions can be either: (a) explicitly marked by an alias <s> or <t>, respectively, in some place within the table expression’s structure, (b) defined by the mark <s> or <t> as a table expression item itself; in this case the sole class maps defined explicitly for the property domain or range class are considered the subject and object class maps for the property map, or (c) in the case of missing explicit <s> and/or <t> marks these marks are assumed <s> for the leftmost and <t> for rightmost item within the table expression.
These conventions allow denoting e.g. the object property map simply by ‘->’, if the property corresponds to the sole FK-to-PK mapping between the tables serving as table expressions in the sole class maps of property domain and range classes.
The data property map can be described by a column name/column expression that is to be evaluated in the context of the sole class map attached to the property domain class. Alternatively, <table_expression>.<value_expression> notation can be used for data property map description, where the table expression is required to contain either explicit or implicit reference <s> to the property map’s subject class map.
The example in Figure 1 contains also an illustration of a function definition using an ontology level rdb2owl:DBExpr annotation, the defined function buildExtInfo is then used in a courseExtInfo property value expression for the Course class. The RDB2OWL functions can be used for repeating mapping fragments, as well as for increasing mapping readability in the case of complex mapping constructions. The function body can introduce also additional table expressions into the context of evaluating its value expression; such table expressions are joined to the table expression defining the context of evaluation of the function-calling value expression.
The decoration ?Out in the database annotation for CompletedRegistration class means relating to this class only those rows of the described class map table expression that contain a value in at least one property whose domain is this class.
A more detailed RDB2OWL language design description can be found in [
The RDB2OWL mapping tool6 takes as the input annotated OWL ontology as well as a connection to the source database (in order to read the source database schema) and it produces a D2RQ mapping for accessing the source database via D2RQ platform7 SPARQL endpoint or RDF dump tool. The database connection information (JDBC driver name and connection information) can be defined as an annotation in the data ontology, or it can be entered directly in the RDB2OWL tool.
The RDB2OWL mapping processing in the tool follows a number of steps
activated either one-by-one or using a batch command “Create mapping from ontology”:
- Load ontology: the ontology with the attached RDB2OWL annotations is
loaded into the internal RDB2OWL mapping model [
Although the navigation item and link construction can be translated into more
basic reference item notation for table expressions corresponding to Raw RDB2OWL
metamodel [
ClassMap classURI:String[0..1] instruction: {?, ?Any, ?Out, ?In} [*] trg 1 An important parameter for the mapping generation is the “with inference” option that can be turned on or off by the user. We explain this parameter using an example. If an ontology class, say, Student, is said to correspond to a database table XStudent, one naturally expects that its superclass (e.g. Person) also automatically receives the instances coming from the XStudent table. If the RDF triples corresponding to the database are dumped and loaded into a RDF triple store (e.g. Virtuoso Server), the RDF triple store can perform the inference. If, however, the RDB data are to be accessed by D2R server on on-the-fly basis, this inference is built into the D2RQ mapping generation by the RDB2OWL tool so that together with the D2RQ class map for the Student class, a similar class map is generated also for the Person class (an alternative would be to extend the D2R server functionality with some inference capabilities). The RDB2OWL tool for D2RQ mapping generation currently supports subclass, subproperty and inverse properties inference. Similar inference capabilities are planned also for upcoming R2RML implementation.
The RDB2OWL tool is implemented in JAVA programming language, however,
its current implementation uses libraries for the internal RDB2OWL model handling
and transformations that are working only in MS Windows environment. The model
transformations from RDB2OWL syntactic to semantic metamodel are written in LuA
programming language using its lQuery model transformation library [
The RDB2OWL mapping language and tool allows easy creation of
database-toontology mappings involving basic one-to-one correspondence between ontology
classes, data and object properties and database tables, columns and relations
respectively, as well as involving more advanced constructs (e.g. adding filters,
subclass relations, value processing, etc.). The experience shows that for simple to
medium size ontologies and corresponding databases the RDB2OWL language and
tool, in combination with D2RQ Platform [
The practical experience of using RDB2OWL over larger ontologies and database
schemas, as in Latvian medicine registries example of [
The direct RDB2OWL mapping text size both in the considered mini-University
and in the Latvian medicine registries [
Regarding the OWL constructions allowed in the ontologies that are RDB2OWL mapping targets, we note that in fact, any OWL features also beyond the RDF Schema notation can be permitted. Figure 1 contains a number of such features, for instance equivalent class assertions and datatype facet restrictions. We can note that the equivalent class assertions for the subclasses of the Teacher class are “enforced” by the RDB2OWL mapping definition; while the facet restrictions in the current mapping version are left to be checked as constraints over the obtained RDF triple set.
Although the RDB2OWL tool has a well-defined task of creating a
conceptuallevel SPARQL endpoint for a relational database, permitting its standalone use, a
particular usage context of the RDB2OWL database-to-ontology mapping tool is
within a larger semantic database platform [