A large part of implementing information retrieval or data mining systems consists of joining data from di erent sources to connect related items, enrich data sets and nd similarities or contradictions. Mediators take care of the conversion between di erent formats and access to the data sources to provide a uni ed view, however these systems either only support read operations or are limited to a schema derived from a xed set of data sources. We sketch a concept for a mediator based on Semantic Web technology { especially RDF/OWL and SPARQL { enriched with semantics from the wrappers and an ontology describing the schema integration. Our system is able to handle updates on the uni ed view, feeding them back to the respective data sources and therefore extends the capabilities of classic data warehouses of federated databases. Furthermore we analyze how CARSA, a meta-search engine framework, can be extended to implement the concept and discuss upcoming problems and ideas for their solution.
With more and more data sources available, it gets harder to integrate the di erent data formats and maintain and link the provided information. Although algorithms for processing the data are independent from their representation, much time must be invested in the development for wrappers and transformation functions between an actual data representation and the one needed for a speci c algorithm, often reimplemented for each distinct data source. Automated converters are available but often su er from the lack of knowledge about semantics necessary to come up with correct conversions.
We elaborate a system that allows to easily plugin data sources and access the contained information, but still is able to propagate back changes on the integrated data. This is The work presented here was supported by the European Commission under the 7th Framework Programme FP7ICT-2007-C FET-Open, contract no. BISON-211898. achieved by adding semantics to the data, using RDF/OWL in combination with Ontologies and custom wrappers, enabling a mediator to integrate arbitrary data sources. With knowledge of the datas' meaning we want to build a system which is able to determine how updates on the RDFbased representation have to be applied to the original data sources, therefore obtaining an integrated view on the data which is no more read-only.
The CARSA framework, developed at the Data and Knowledge Engineering Group, will be used to implement the concept. Existing solution for RDF-based mediation and query planning shall be integrated if possible.
This paper gives a short overview on related work according data integration and Semantic Web technologies and afterwards presents out hitherto ideas on such mediator system, closing with an outlook on the next steps and plans on future development.
Related work comes from the eld of Databases, especially data integration, which is concerned with a uni ed view on data from multiple, heterogeneous sources, and the eld of Data and Knowledge Engineering, providing Semantic Web technology which we use to represent information in our system.
In general, Data Sources (DS) are autonomous with respect to design, schema, if any is de ned, data model and management. Often they are created in advance on usually not with integration in mind. In a data integration system, queries are processed by translating them into (sub-)queries in a form appropriate for the DS which is known to contain the respective data. This is not a trivial task as di erent DS may have di ering models and access limitations have to be considered. Among heterogeneity in hardware and communication protocols, logical di erences are the most intricate problem. If the DS are limited to relational database systems, there are no model con icts and de ned schemas are available, thus lessening the problem. However, not all data sources encountered do have this form.
Distributed Database Systems (DBS) are integrated, mostly
homogeneous DBS where the distribution is known in
advance.[
Federated Database Systems (FDBS) consist of
semi-autonomous components { in the role of DS { which have been
extended by an interface to communicate with each other,
where each component is a centralized or distributed DBMS
of itself. Tightly coupled FDBS have one or a uni ed schema,
which is static and therefore makes it hard to add additional
DS. Loosely coupled FDBS do not have a uni ed schema
and the components are more autonomous. With no global
schema, each source can create its own federated schema.
Logical heterogeneity has to be solved manually by experts.
This concept is suitable for a small number of (autonomous)
sources if their independence has to be retained. [
The Semantic Web[
The Resource Description Framework (RDF)2 is a format for describing of relationships between a source (subject) and a target (object). Uni ed Resource Identi ers (URIs) are used to specify each component, making these descriptions unique. The Web Ontology Language (OWL)3 can be used to describe ontologies, i.e. formal representations of concepts and their relationships. By combining both frameworks, it is possible to represent information and their relationships from arbitrary data sources.
As it is possible to describe concepts and relationships in di erent ways { resulting in di erent ontologies describing the same circumstance { ontologies need to be aligned. This process can be compared to creating a uni ed schema in DBS. If two ontologies can be mapped to each other, so can the information represented by two data sources using them. In our approach we rely on ontology matching as a replacement for schema mapping, however do not research the topic ourselves.
Similar to SQL queries in relational DBMS, SPARQL4 has been developed as a query language for the Semantic Web. The syntax is similar to SQL, however it is tailored towards RDF-graphs. We use SPARQL as query language, matching the RDF representation of the integrated data.
Since RDF/OWL and RDBMS both describe data sets, there
have been e orts to bridge the concepts and transform data
between these models. In [
Due to available XML representations of RDF graphs, it
is tempting to use XML technology and XML databases to
represent RDF. However, as pointed out in [
Semantic Web technologies and data integration have al
A typical task in PIM data integration can be to merge several address books from di erent sources, such as Social Networks, e.g. Facebook5 or Xing6, a personal address book in the PDA or mobile phone and a company-wide address book provided by LDAP or other software. Even though there are di erent sources to the user only the actual entry is relevant.
While views can often be integrated by merging all available data into a contact item, this often leads to information loss with respect to the source of information and relevance of con icting parts. When, for example. the merge results in several phone numbers, the user has to choose which one would be correct in the current context, so he does not end up making business calls on the personal land-line. Semantic annotations, especially about the source, can be used to rank con icting items in the integrated view.
Another question { and more relevant regarding this paper { is how updates on an integrated data set should be applied. When the user changes a speci c phone number, in which data source must this change be committed? Information about the semantics of integrated data and their sources can be used to guide this decision, Section 5.2 however points out some problems which will arise due to intrinsic lack of information. Here a system can try to deduce where information must be put from the context and habits of a user, e.g. are phone numbers stored in Xing or rather in the personal address book and can a certain update be made at all?
The CARSA system7 as initially described in [
At the time of writing this paper we have already begun to
enhance the CARSA system by Semantic Web capabilities,
i.e. handling of RDF graphs and SPARQL-based requests.
The existing plugin architecture will then be used to
incorporate wrappers between arbitrary data sources and the
RDFbased internal representation. If necessary we extend these
plugins to be general data access plugins, enabling them to
not only read from, but also to update the data sources.
The available query routing mechanism will be leveraged to
implement the mediator structure described in [
Instead of a uni ed schema, which would require adaption whenever a data source is plugged in or removed, we use the semantics of the represented data to determine how updates must be conducted. The user applies changes to the RDF view, i.e. updates, deletions and additions. The mediator then determines how the underlying data sources have to be manipulated in order to re ect the desired change in the RDF representation. By changing the RDF graph the user conveys the intention to change the underlying data sources in such way that their representation will result in the changed RDF graph.
The interactions which are available on the RDF-based information view must match the interactions for similar integrated views (see Related Work) and should also allow to change the underlying data sources through the presented view.
The read-only interaction schemes on the view can be classi ed as Lookups as closed queries to the RDF representation. These are achieved via SPARQL queries and part of the implementation of available RDF frameworks. Rather than looking for speci c structures directly, the user may have open queries and therefore must be able to Navigate through the data in order to Explore it. Hitherto existing solutions are already capable of supporting these interactions.
Additional to the above, we also want to allow changes in the data representation. These changes may be: 1. Update already existing items or their properties: For these changes, the data source of the item { or the property { is identi ed and the update applied there. Problems may arise if the change can only be re ected by moving the item between data sources. 2. Delete items or their properties: Similar to an update, the data source must be identi ed and the item deleted from there. If an item appears on several data sources and has been merged, it must be deleted from each of them or the removal must be disambiguated. 3. Add items or properties: In contrast to the above manipulations, there is no known data source for an added item. The mediator needs to determine the data source in which the item should be created in order to show up in the RDF view. Dependent on the incorporated sources, it may be necessary to disambiguate between several update actions, as elaborated in the Disambiguation section below.
For accumulated values or items, which have been assembled from multiple source, the update operations may not be as straightforward as listed above. For example an accumulated value, such as the number of books a person owns, can only be changed be adding or removing books { these values cannot be directly manipulated. Also, not every data source may support the desired update. The mediator has to keep track of which interactions are available on the presented data. So far we came up with two solutions, both having their advantages and drawbacks: 1. On each intended update the system can perform a dry run and report whether the operation would be successful. While this solution is relatively easy to implement, it is not acceptable from a user's point of view. Neither is the system able to tell whether a planned operation would be possible, nor is it possible to enumerate available interactions to be presented to the user. These limitations deter the user from building a successful mental simulation towards the solution of a task at hand, therefore make it very di cult to achieve a speci c goal when interacting with the system. 2. Based on limitations stated in meta-information about data sources, the mediator can keep track of constraints towards the interactions available for the system. From those constraints a set of interactions can be derived for each item in the RDF graph and be presented to the user. This solution, however, results in a much higher e ort on developing, implementing and running the mediator system.
As there may be data sources with similar semantics, e.g. person pro les from social networks, it may not always be possible to decide which data source should be changed in order to achieve a certain state. This especially applies to added information, as there is no history or meta-data for this piece of information which would allow to map it to a data source. In order to solve the problem, an explicit disambiguation is necessary, for which we have so far elaborated several approaches: 1. The user is presented with a list of possible actions through the user interfaces, from where he is asked to select one to his like. This solution has two major drawbacks: First, there must be a user interface at all, which might not necessarily be the case with agent-based systems. Second, the user might not know or might not want to be concerned with the selection of an appropriate data source to be changed. This form of presentation breaks the uni ed view on all data sources. 2. There is a reasoning mechanism which allows to determine the best action to be taken. This might be achieved by a ranking of all possible changes, based on meta-information about the data sources provided by their wrappers. This ranking, however, will be very closely tied to the actual application and must be carefully designed to re ect the user's needs, otherwise odd decisions may lead to confusion. Still, there is a Semantic Gap between a user's interaction and his intent, for example an application could not easily deduce in which contact to store a just added telephone number. Unless there are clear directions about where to put speci c data, the user may still need to make the decision. 3. The reasoning may be supported by nding similar data and deducing the target data source by these elements. This approach is based on the assumption that a user intends to keep the principal structure of his data models. So when a telephone number is added to a contact, the system tries to determine the source which is most likely to contain telephone numbers and puts the number there. Previous choices by the user may be incorporated.
Selecting from these approaches is a choice between automation and accuracy. None of these approaches provides a perfect solution and it is most likely necessary to combine them to create a ranking of possible actions and present them to the user for a more informed choice.
As mentioned in Section 2.3, there are solutions for an automated mapping of relational data schemas to RDF structures. However, in most database schemas semantics are not included and often even distorted by normalization or optimization, therefore many data sources are missing the necessary information needed to implement a semantic driven system.
This semantic gap is closed by writing wrappers which
explicitly take care of adding and removing semantics during
transformation. In [
Based on the CARSA framework described in Section 4 we
plan to implement an architecture similar to the one
described in [
We sketched a system that combines techniques both from data integration and the Semantic Web to integrate multiple data sources while keeping their semantics, which can be used for further processing without the need of data source speci c converters. Having the semantics of each item allows not only to read, but also to apply updates on the uni ed view, as the mediator can determine the original source in which the changes have to be made. Some approaches for the disambiguation of changes have been presented, as it may not always be decidable to which source an update must be forwarded.
Since we do not build a Data Warehouse, but access the sources directly, changes { either external or from within the system { have immediate e ect, making the mediator also usable for short-living data or high update rates, as they may appear for example in Personal Information Management (PIM).
The system will serve as a basis for uni ed navigation, exploration and manipulation of integrated data sources. While starting with a system for read-only, yet dynamic access, we strongly aim at update support using the semantic annotations.
First thing to do will be the extension of the CARSA
system by RDF capabilities as described in Section 4. Together
with this development, we will assert how exactly the
mentioned solutions for query federation can be incorporated
into our framework. Afterwards, a prototype system
integrating several sources from PIM and knowledge bases is
built to research aspects of performance and and e ciency,
alongside with a user interfaces that allows interaction with
the data made available via the RDF mediator, leveraging
existing tools for graph exploration and information
visualization based on the represented data structures.
An interesting notion is the alignment of the de nition of
information provided by [
We left out the whole aspect of transactions. In our prototype we assume that each operation will be successful and executed towards the ACID criteria. A system which is able to ensure this environment with multiple, independent data sources is left for later research.