Schema Evolution publication categorizer

Recent position papers demand more schema flexibility, such as the ability to handle variational data [3, 42]. Many agile software developers have long since turned towards NoSQL database systems such as MongoDB 1, Couchbase 2, or ArangoDB 3 which are schema-flexible, or even altogether schema-free. They allow to store datasets in different structural versions to co-exist. Yet even when the database management system does not maintain an explicit schema, there is commonly an implicit schema, as the application code makes assumptions about the structure of the stored data.

Semantic annotations are often used to enrich documents as clinical trials and
electronic health records. However, the usability of these annotations tends to decrease over
time due to the evolution of the domain ontologies. The maintenance of these annotations is
critical for tools that exploit them (eg, search engines and decision support systems) in order
to assure an acceptable level of performance. Despite the recent advances in ontology
evolution systems, the maintenance of semantic annotations remains an open problem. In

Mapping complex metadata structures is crucial in a number of domains such as data integration, ontology alignment or model management. To speed up that process automatic matching systems were developed to compute mapping suggestions that can be corrected by a user. However, constructing and tuning match strategies still requires a high manual effort by matching experts as well as correct mappings to evaluate generated mappings. We therefore propose a self-configuring schema matching system that is able to automatically adapt to the given mapping problem at hand.

Benchmarking approaches for ontology merging is challenging and has received little attention so far. A key problem is that there is in general no single best solution for a merge task and that merging may either be performed symmetrically or asymmetrically. As a first step to evaluate the quality of ontology merging solutions we propose the use of general metrics such as the relative coverage of the input ontologies, the compactness of the merge result as well as the degree of introduced redundancy. We use these metrics to evaluate three merge approaches for different merge scenarios.

There is an increasing need to interrelate different life science ontologies in order to facilitate data integration or semantic data analysis. Ontology matching aims at a largely automatic generation of mappings between ontologies mostly by calculating the linguistic and structural similarity of their concepts. In this paper we investigate an indirect computation of ontology mappings that composes and thus reuses previously determined ontology mappings that involve intermediate ontologies. The composition approach promises a fast computation of new mappings with reduced manual effort.

Schema evolution is an unavoidable consequence of the application development lifecycle. The two primary schemas in an application, the conceptual model and the persistent database model, must co-evolve or risk quality, stability, and maintainability issues. We study application-driven scenarios, where the conceptual model changes and the database and mapping must evolve in kind. We present a technique that, in most cases, allows those evolutions to progress automatically. We treat the mapping as data, and mine that data for patterns.

Matching life science ontologies to determine ontology mappings has recently become an active field of research. The large size of existing ontologies and the application of complex match strategies for obtaining high quality mappings makes ontology matching a resource- and time-intensive process. To improve performance we investigate different approaches for parallel matching on multiple compute nodes. In particular, we consider inter-matcher and intra-matcher parallelism as well as the parallel execution of element- and structure-level matching.

Ontologies are heavily used in life sciences and evolve continuously to incorporate new or changed insights. Often ontology changes affect only specific parts (regions) of ontologies making it valuable for ontology users and applications to know the heavily changed regions on the one hand and stable regions on the other hand. However, the size and complexity of life science ontologies renders manual approaches to localize changing or stable regions impossible. We therefore propose an approach to automatically discover evolving or stable ontology regions.

A recurring manual task in data integration, ontology alignment or model management is finding mappings between complex meta data structures. In order to reduce the manual effort, many matching algorithms for semi-automatically computing mappings were introduced. Unfortunately, current matching systems severely lack performance when matching large schemas. Recently, some systems tried to tackle the performance problem within individual matching approaches. However, none of them developed solutions on the level of matching processes.

This paper discusses the topic of using view mechanism to simulate schema modifications without database reorganisation in Object Oriented Database Systems. Our approach allows each user to specify the schema modifications to his own virtual schema rather than to the base schema shared by many users. One of the main advantages provided by this approach is the preservation of the independence of existing application programs from the schema evolution. The most important issue concerns the control and sharing of the information introduced by capacity-augmenting views.

An increasing number of scientific communities rely on Semantic Web ontologies to share and interpret data within and across research domains. These common knowledge representation resources are usually developed and
maintained manually and essentially co-evolve along with experimental evidence produced by scientists worldwide. Detecting automatically the differences between (two) versions of the same ontology in order to store or visualize their

Ontology matching has been widely studied. However, the resulting ontology mappings can be rather unstable when the participating ontologies or utilized secondary sources (e.g., instance sources, thesauri) evolve. We propose an evolution-based approach for assessing ontology mappings by annotating their correspondences by information about similarity values for past ontology versions. These annotations allow us to assess the stability of correspondences over time and they can thus be used to determine better and more robust ontology mappings.

Relational databases have been designed to store high volumes of data and to provide an efficient query interface. Ontologies are geared towards capturing domain knowledge, annotations, and to offer high-level, machine-processable views of data and metadata. The complementary strengths and weaknesses of these data models motivate the research effort we present in this paper. The goal of this work is to bridge relational and ontological worlds, in order to leverage the efficiency and scalability of relational technologies to support an ontological, high level view of data and metadata.

During data warehouse design, the designer frequently encounters the problem of choosing among different alternatives for the same design construct. The behavior of the chosen design in the presence of evolution events is an important parameter for this choice. This paper proposes metrics to assess the quality of the warehouse design from the viewpoint of evolution. We employ a graph-based model to uniformly abstract relations and software modules, like queries, views, reports, and ETL activities. We annotate the warehouse graph with policies for the management of evolution events.

The administrators and designers of modern Information Systems face the problem of maintaining their systems in the presence of frequently occurring changes in any counterpart of it. In other words, when a change occurs in any point of the system –e.g., source, schema, view, software construct– they should propagate the change in all the involved parts of the system.

Databases are continuously evolving environments, where design constructs are added, removed or updated rather often. Small changes in the database configurations might impact a large number of applications and data stores around the system: queries and data entry forms can be invalidated, application programs might crash. HECATAEUS is a tool, which represents the database schema along with its dependent workload, mainly queries and views, as a uniform directed graph.

Databases are continuously evolving environments, where design constructs are added, removed or updated rather often. Research has extensively dealt with the problem of database evolution. Nevertheless, problems arise with existing queries and applications, mainly due to the fact that, in most cases, their role as integral parts of the environment is not given the proper attention. Furthermore, the queries are not designed to handle database evolution. In this paper, we introduce a graph-based model that uniformly captures relations, views, constraints and queries.

In this paper we study the problem of schema exchange, a
natural extension of the data exchange problem to an intensional level.
To this end, we first introduce the notion of schema template, a tool for
the representation of a class of schemas sharing the same structure. We
then define the schema exchange notion as the problem of (i) taking a
schema that matches a source template, and (ii) generating a new schema
for a target template, on the basis of a set of dependencies defined over
the two templates. This framework allows the definition, once for all,

The translation of information between heterogeneous rep-
resentations is a long standing issue. With the large spreading of cooper-
ative applications fostered by the advent of the Internet the problem has
gained more and more attention but there are still few and partial solu-
tions. In general, given an information source, different translations can
be defined for the same target model. In this work, we first identify gen-
eral properties that “good” translations should fulfill. We then propose
novel techniques for the automatic generation of model translations. A

Schema merging is the process of integrating several schemas into a common, unified schema. There have been various approaches to schema merging, focusing on particular modeling languages, or using a lightweight, abstract metamodel. Having a semantically rich representation of models and mappings is particularly important for merging as semantic information is required to resolve the conflicts encountered. Therefore, our approach to schema merging is based on the generic role-based metamodel GeRoMe and intensional mappings based on the real world states of model elements.

Clio is an existing schema-mapping tool that provides user-friendly means to manage and facilitate the complex task of transformation and integration of heterogeneous data such as XML over the Web or in XML databases. By means of mappings from source to target schemas, Clio can help users conveniently establish the precise semantics of data transformation and integration. In this paper we study the problem of how to efficiently implement such data transformation (i.e., generating target data from the source data based on schema mappings).

We address the problem of generating a mediated schema from a set of relational data source schemas and conjunctive queries that specify where those schemas overlap. Unlike past approaches that generate only the mediated schema, our algorithm also generates view definitions, i.e., source-to-mediated schema mappings.

A major advantage of Service-Oriented Architectures (SOA) is composition and coordination of loosely coupled services. Because the development lifecycles of services and clients are decoupled, multiple service versions have to be maintained to continue supporting older clients. Typically versions are managed within the SOA by updating service descriptions using conventions on version numbers and namespaces. In all cases, the compatibility among services description must be evaluated, which can be hard, error-prone and costly if performed manually, particularly for complex descriptions.

The ability to cope with multiple competing stakeholders, fluid requirements, emergent behavior, and susceptibility to external pressures that can cause changes across an entire organization, coupled with the ability to support service diversification, is a key to an enterprise’s competitiveness. Web services equip enterprises with the potential to react to change by addressing two interrelated sets of requirements: the ability to accommodate service changes that demand rapid response and to support service variation according to customers’ needs and requirements.

Conceptual-relational mappings between conceptual models and relational schemas have been used increasingly to achieve interoperability or overcome impedance mismatch in modern data-centric applications. However, both schemas and conceptual models evolve over time to accommodate new information needs. When the conceptual model (CM) or the schema associated with a mapping evolved, the mapping needs to be updated to reflect the new semantics in the CM/schema.