Valéria Magalhães Pequeno

Specifying complex correspondences between relational schemas and RDF models for generating customized R2RML mappings

The W3C RDB2RDF Working Group proposed a standard language to map relational data into RDF triples, called R2RML. However, creating R2RML mappings may sometimes be a difficult task because it involves the creation of views (within the mappings or not) and referring to them in the R2RML mapping. To overcome such difficulty, this paper first proposes algebraic correspondence assertions, which simplify the definition of relational-to-RDF mappings and yet are expressive enough to cover a wide range of mappings. Algebraic correspondence assertions include data-metadata mappings (where data elements in one schema serve as metadata components in the other), mappings containing custom value functions (e.g., data format transformation functions) and union, intersection and difference between tables. Then, the paper shows how to automatically compile algebraic correspondence assertions into R2RML mappings.

Using Changesets for Incremental Maintenance of Linkset Views

In the Linked Data field, data publishers frequently materialize linksets between two datasets using link discovery tools. However, when the datasets are continually updated, a materialized linkset must also be updated since the links may no longer meet the linkage rules. To help solve this problem, this paper presents an approach for maintaining linksets, which treats linksets as materialized views, is based on changesets and adopts an incremental strategy. The paper formalizes the materialized linkset maintenance problem based on changesets and indicates that our approach correctly maintains materialized linksets views. Finally, it suggests an architecture and describes an implementation and experiments to validate the proposed approach.

Towards Semi-automatic Generation of R2R Mappings.

Translating data from linked data sources to the vocabulary that is expected by a linked data application requires a large number of mappings and can require a lot of structural transformations as well as complex property value transformations. The R2R mapping language is a language based on SPARQL for publishing expressive mappings on the web. However, the specification of R2R mappings is not an easy task. This paper therefore proposes the use of mapping patterns to semi-automatically generate R2R mappings between RDF vocabularies. In this paper, we first specify a mapping language with a high level of abstraction to transform data from a source ontology to a target ontology vocabulary. Second, we introduce the proposed mapping patterns. Finally, we present a method to semi-automatically generate R2R mappings using the mapping

Framework for Live Synchronization of RDF Views of Relational Data.

This Demo presents a framework for the live synchronization of an RDF view defined on top of relational database. In the proposed framework, rules are responsible for computing and publishing the changeset required for the RDB-RDF view to stay synchronized with the relational database. The computed changesets are then used for the incremental maintenance of the RDB_RDF views as well as application views. The Demo is based on the LinkedBrainz Live tool, developed to validate the proposed framework.

Rubya: A Tool for Generating Rules for Incremental Maintenance of RDF Views

We present Rubya, a tool that automatically generates the RDF view defined on top of relational data and all rules required for the incremental maintenance of the RDF view. Our approach relies on the designer to specify a mapping between the relational schema and a target ontology and results in a specification of how to represent relational schema concepts in terms of RDF classes and properties of the designers choice. Based on this mapping, the rules for incrementally maintenance of the RDF view are generated.

Specifying Complex Correspondences Between Relational Schemas in a Data Integration Environment

When dealing with the data integration problem, the designer usually encounters incompatible data models characterized by differences in structure and semantics, even in the context of a same organization. In this work, we propose a declarative and formal approach to specify correspondences between relational schema components. Our Correspondence Assertions (CAs) can specify 1-to-1 and m-to-n correspondences with semantics. We propose to adapt CAs to be able to express schema matching between relational schemas, as well as to extend this formalism with new types of CAs to deal with joins, outer-joins, and data-metadata relationships. Finally, we demonstrate how mapping expressions in the form of SQL queries can be generated from CAs.

Using Complex Correspondences for Integrating Relational Data Sources

Data Integration (DI) is the problem of combining a set of heterogeneous, autonomous data sources and providing the user with a unified view of these data. Integrating data raises several challenges, since the designer usually encounters incompatible data models characterized by differences in structure and semantics. One of the hardest challenges is to define correspondences between schema elements (e.g., attributes) to determine how they relate to each other. Since most business data is currently stored in relational databases, here present a declarative and formal approach to specify 1-to-1, 1-m, and m-to-n correspondences between relational schema components. Differently from usual approaches, our (CAs) have semantics and can deal with outer-joins and data-metadata relationships. Finally, we demonstrate how to use the CAs to generate mapping expressions in the form of SQL queries, and we present some preliminary tests to verify the performance of the generated queries.