Schema Evolution publication categorizer

We briefly motivate and present a new online bibliography on schema evolution, an area which has recently gained much interest in both research and practice.

Many problems encountered when building applications of database systems involve the manipulation
of models. By “model,” we mean a complex structure that represents a design artifact,
such as a relational schema, object-oriented interface, UML model, XML DTD, web-site schema,
semantic network, complex document, or software configuration. Many uses of models involve
managing changes in models and transformations of data from one model into another. These uses
require an explicit representation of “mappings” between models. We propose to make database

We describe MIDST, an implementation of the model management
operator ModelGen, which translates schemas from one model
to another, for example from OO to SQL or from SQL to XSD. It extends
past approaches by translating database instances, not just their
schemas. The operator can be used to generate database wrappers (e.g.
OO or XML to relational), default user interfaces (e.g. relational to
forms), or default database schemas from other representations. The approach
translates both schemas and data: given a source instance I of a

Composition of mappings between schemas is essential to support
schema evolution, data exchange, data integration, and other data
management tasks. In many applications, mappings are given by
embedded dependencies. In this paper, we study the issues involved
in composing such mappings.
Our algorithms and results extend those of Fagin et al. [8] who
studied composition of mappings given by several kinds of constraints.
In particular, they proved that full source-to-target tuplegenerating
dependencies (tgds) are closed under composition, but

The goal of schema matching is to identify correspondences between the elements of two schemas.
Most schema matching systems calculate and display the entire set of correspondences in a single
shot. Invariably, the result presented to the engineer includes many false positives, especially for

Mapping composition is a fundamental operation in metadata
driven applications. Given a mapping over schemas S1 and S2 and
a mapping over schemas S2 and S3, the composition problem is
to compute an equivalent mapping over S1 and S3. We describe
a new composition algorithm that targets practical applications. It
incorporates view unfolding. It eliminates as many S2 symbols as
possible, even if not all can be eliminated. It covers constraints
expressed using arbitrary monotone relational operators and, to a
lesser extent, non-monotone operators. And it introduces the new

The future of the Semantic Web depends on whether or not we succeed to integrate reliably thousands of online applications, services, and databases. These systems are tied together using mediators, mappings, database views, and transformation scripts. Model-management aims at reducing the amount of programming needed for the development of such integrated applications. We present a first complete prototype of a generic model-management system, in which high-level operators are used to manipulate models and mappings between models.

Schema matching is a critical step in many applications, such as XML message mapping, data warehouse loading, and schema integration. In this paper, we investigate algorithms for generic schema matching, outside of any particular data model or application. We first present a taxonomy for past solutions, showing that a rich range of techniques is available. We then propose a new algorithm, Cupid, that discovers mappings between schema elements based on their names, data types, constraints, and schema structure, using a broader set of techniques than past approaches.

ion of operations on models and mappings  something much higher level than navigating object structures. Some candidate operators are: x Match – automatically create a mapping between two models. x Merge – merge two models into a third, or merge one model into another based on a mapping. x Compose – return the composition of two mappings (if map

A model is a formal description of a complex application artifact, such as a database schema, an application interface, a UML model, an ontology, or a message format. The problem of merging such models lies at the core of many meta data applications, such as view integration, mediated schema creation for data integration, and ontology merging. This paper examines the problem of merging two models given correspondences between them. It presents requirements for conducting a merge and a specific algorithm that subsumes previous work.

Mappings between disparate models are fundamental to any
application that requires interoperability between heterogeneous
data and applications. Generating mappings is a laborintensive
and error prone task. To build a system that helps
users generate mappings, we need an explicit representation
of mappings. This representation needs to have well-defined
semantics to enable reasoning and comparison between mappings.
This paper first presents a powerful framework for
defining languages for specifying mappings and their associated
semantics. We examine the use of mappings and identify

In a Web database that dynamically provides information in response to user queries, two distinct schemas, interface schema (the schema users can query) and result schema (the schema users can browse), are presented to users. Each partially reflects the actual schema of the Web database. Most previous work only studied the problem of schema matching across query interfaces of Web databases. In this paper, we propose a novel schema model that distinguishes the interface and the result schema of a Web database in a specific domain.

Model management is an approach to simplify the programming
of metadata-intensive applications. It offers developers powerful
operators, such as Compose, Diff, and Merge, that are applied to
models, such as database schemas or interface specifications, and
to mappings between models. Prior model management solutions
focused on a simple class of mappings that do not have executable
semantics. Yet many metadata applications require that mappings
be executable, expressed in SQL, XSLT, or other data transformation
languages.
In this paper, we develop a semantics for model-management

The difficulty inherent in schema matching has led
to the development of several generic match algorithms.
This paper describes how we adapted general
approaches to the specific task of aligning two ontologies
of human anatomy, the Foundational Model of
Anatomy and the GALEN Common Reference Model.
Our approach consists of three phases: lexical, structural
and hierarchical, which leverage different aspects
of the ontologies as they are represented in a
generic meta-model. Lexical matching identifies concepts
with similar names. Structural matching identifies

Most information systems rely on meta data artifacts, such as database schemas, interface specifications, or view definitions, to store, transform, validate, and exchange information. Applications that produce and manipulate these meta data artifacts are complex and hard to build. The goal of model management research is to develop a set of powerful high-level operators that simplify the programming of such applications, and increase the productivity of developers by an order of magnitude.

Model management aims at reducing the amount of programming needed for the development of metadata-intensive applications. We present a first complete prototype of a generic modelmanagement system, in which high-level operators are used to manipulate models and mappings between models. We define the key conceptual structures: models, morphisms, and selectors, and describe their use and implementation. We specify the semantics of the known model-management operators applied to these structures, suggest new ones, and develop new algorithms for implementing the individual operators.

Model management is a framework for supporting meta-data related applications where models and mappings are manipulated as first class objects using operations such as Match, Merge, ApplyFunction, and Compose. To demonstrate the approach, we show how to use model management in two scenarios related to loading data warehouses. The case study illustrates the value of model management as a methodology for approaching meta-data related problems. It also helps clarify the required semantics of key operations.

Model management is a new approach to meta data management that offers a higher level programming interface than current techniques. The main abstractions are models (e.g., schemas, interface definitions) and mappings between models. It treats these abstractions as bulk objects and offers such operators as Match, Merge, Diff, Compose, Apply, and ModelGen. This paper extends earlier treatments of these operators and applies them to three classical meta data management problems: schema integration, schema evolution, and round-trip engineering.