-
Notifications
You must be signed in to change notification settings - Fork 10
KroObdascenario
The objective of this project is to demonstrate the use of DL-LiteA, reasoning and OBDA in an application scenario. Given a domain of interest, you will demonstrate interesting uses of OBDA technology (ontologies, and mappings to relational database) as to provide more functionality than that that could be obtained by using only relational databases.
You will start the project by choosing an application domain and by defining a concrete scenario in which OBDA technology is applied to complete a concrete task that would be impossible or harder using simply relational technology. For example:
- Providing semantics to tags in the creation of 'Semantic' blogs, wiki's, etc.
- Performing data aggregation of multiple sources in an industrial domain/
- Providing a clean view of a database that has suffered schema degradation,
that has missing data, etc.
- Creating 'semantic' variations of everyday tasks such as music library
organization, etc.
Your first task will be to define the specific domain and application in detail. One the proposal is clear, you will proceed with the development of a system architecture over which you will base your application. At the same time you will develop your database and ontology with mappings. Finally, you will develop a system (web based or stand alone application) that provides the services that you define in your proposal.
Evaluation of the project will be according two two criteria. First, you should use DL-LiteA expressivity, mappings and conjunctive queries to provide a creative use of semantics that indeed solves or easies some task that is normally harder in the relational database setting. Second, the quality of the application you develop should be enough as to allow a) a user to access all the functionality with out unexpected results b) a developer to go through your code and understand its' organization.
With respect to the model, you will provide the .owl and .obda files for the model of your application. These will account for your DL-LiteA ontology, the mappings of your model and the queries that your system issues to the reasoner. You will also provide an SQL dump of the database you create for this project.
With respect to the software, the API of the project should be properly modularized with components that handle each of the task involved in the system as independent operations . Each of these modules should be properly documented using JavaDoc and inline comments. A document including the whole system architecture should be provided.
The final package of the project should include
- A executable JAR (or WAR in case of a web application) that allows to start the application
- .OWL .OBDA and .SQL files containing your model.
- Means to build and pack the project from the sources. For this task, and to facilitate the management and definition of dependencies (e.g., Jars from libraries used for the project such as the OWLAPI, H2, etc) it is recommended that the project is setup to use Maven 2. A quick start guide for Maven 2 can be found here. If the project is developed using Eclipse it is recommended the use of the m2Eclipse plugin to facilitate development.
The ontology in this project should be complex enough to provide added value as opposed to using the database directly. With this in mind consider the following minimal requirements:
- At least 25 Classes, 20 Object properties, 20 Datatype Properties
- At least 3 hierarchies in the classes tree, at least one of them of depth 4
- At least 2 hierarchies in the each property tree.
- Usage of disjointness, existential quantification and functionality assertions.
- 8 Tables
- Proper declaration of primary keys and foreign keys.
- A minimum of 50MB of data. If you are creating the database yourself then you will need a data generation tool like Data Generator, or Benerator.
With respect to you the mapping layer the minimal requirements are:
- 40 mappings
- At least 15 mappings using join operations
- At least 15 mappings using WHERE clauses
- At least 5 mappings using aggregation functions or NOT IN expressions
With respect to the queries in your application the minimal requirements are:
- At least 25 queries with an average length of 7 atoms
- At least 10 queries were at least 1 constant value is used. For example,
SELECT ?x WHERE {
?x :hasFather ?y.
?y :age 61 .
?y :firstName 'John'.
}
- First deliverable. Document describing the application domain and the intended scenario making emphasis on the use queries over the ontology as opposed to queries over the database. The document should also include a description of the architecture of the system that is going to be build on top of the ontology.
- Second deliverable. An initial overview of the status of the implementation detailing open issues.
- Third and final deliverable. A final document including the updated architecture and system proposal to reflect the final stage of the development. A simple user manual for the application. The software package described above.
- OBDA Software documentation Use the examples in the bottom right as a reference to interface with the quonto reasoner.
- Tractable reasoning and efficient query answering in description logics: The DL-Lite family. Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, and Riccardo Rosati. J. of Automated Reasoning, 39(3):385-429, 2007. pdf
- Ontologies and databases: The DL-Lite approach. Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, Antonella Poggi, Mariano Rodriguez-Muro, and Riccardo Rosati. In Sergio Tessaris and Enrico Franconi, editors, Semantic Technologies for Informations Systems - 5th Int. Reasoning Web Summer School (RW 2009), volume 5689 of Lecture Notes in Computer Science, pages 255-356. Springer, 2009.
- Linking data to ontologies Antonella Poggi, Domenico Lembo, Diego Calvanese, Giuseppe De Giacomo, Maurizio Lenzerini, and Riccardo Rosati. J. on Data Semantics, X:133-173, 2008. pdf