Schema Evolution publication categorizer

Information integration is a key challenge faced by all major organizations, business and governmental ones alike. Two research facets of this challenge that have received considerable attention in recent years are data exchange and data integration. The study of data exchange and data integration has been facilitated by the systematic use of schema mappings, which are high-level specifications that describe the relationship between two database schemas.

In this article we present extensional mappings, that are based on second order tuple generating dependencies between models in our Generic Role-based Metamodel GeRoMe. Our mappings support data translation between heterogeneous models, such as XML Schemas, relational schemas, or OWL ontologies. The mapping language provides grouping functionalities that allow for complete restructuring of data, which is necessary for handling object oriented models and nested data structures such as XML. Furthermore, we present algorithms for mapping composition and optimization of the composition result.

Modern information systems, and web information systems in particular, are faced with frequent database schema changes, which generate the necessity to manage such evolution and preserve their history.

Due to its extensive potential applications, model management has attracted many research interests and gained great progress. To provide easy-to-use interfaces, we have proposed a graph transformation-based model management approach that provides intuitive interfaces for manipulation of graphical data models. The approach consists of two levels of graphical operators: low-level customizable operators and high-level generic operators, both of which consist of a set of graph transformation rules. Users need to program or tune the low-level operators for desirable results.

Model management is a generic approach to solving problems of data programmability where precisely engineered mappings are required. Applications include data warehousing, e-commerce, object-to-relational wrappers, enterprise information integration, database portals, and report generators. The goal is to develop a model management engine that can support tools for all of these applications. The engine supports operations to match schemas, compose mappings, diff schemas, merge schemas, translate schemas into different data models, and generate data transformations from mappings.

The concept of “model” is today considered as a promising technology in domains such as
data and software engineering. In the field of model engineering, models are now viewed as
firts-class entities. This new approach makes it possible to envision the integration of models
into engineering processes. Such an integration will however require a set of dedicated tools
enabling to perform standard model operations onto handled models. We strongly believe that,
in order to achieve usability for large communinities of users, model-based tools have to rely

The basic assumption in model engineering (MDE) is to consider
models as first class entities. One of the most important kinds of models in
MDE approaches are transformation models. Transformation models define
operations between different models. However, there are many operations that
are not efficiently handled by generic model transformations. For example,
models transformations are not adapted to define and to capture relationships
between models elements. Relationships between model elements are present in

It is desirable to be able to interchange design information between CASE tools. Such interchange facilitates cooperative development, helps in avoiding legacy problems when adopting new tools, and permits the use of different tools for different life-cycle activities. Exchanging model transformation information is particularly demanding in the context of cooperative main-tenance of evolving systems. In this paper we suggest an approach using active transformation rules.

We develop a formal basis of correct schema transformations. Schemas are formalized as abstract data types, and correct schema transformations are formalized as information-preserving signature interpretations. Our formalism captures transformations of all schema components, making it possible to transform uniformly constraints and queries along with structures. In addition, our formalism captures schema transformations between different data models as easily as those within the same data...

Several methodologies for integrating database schemas have been
proposed in the literature,
using various common data models (CDMs). As part of these
methodologies transformations
have been defined that map between schemas which are in some sense
equivalent.
This paper describes a general framework for formally underpinning
the schema transformation
process. Our formalism clearly identifies which transformations apply
for any instance
of the schema and which only for certain instances. We illustrate the
applicability of the

This paper presents an intermediate meta-model that consists
of a set of generic meta-classes that capture and describe
the semantics of a variety of data models. A model is
described by a set of intermediate model meta-classes (organized
in the form of a directed acyclic graph (DAG) to
achieve extensibility y), while irtst antes of these meta-classes
are used to describe a schema in a given data model. The
proposed approach supports dynamic meta-schema comparison
and transformation by employing special-purpose transformation
rules.

In this paper we study the problem of translating schemes between
different data models,
in a formal framework that refers to a wide range of models. We first
introduce a graphtheoretic
formalism that allows us to uniformly represent schemes and models,
to compare
different data models and to describe the behavior of basic
translations. The formalism
is based on a classification of the constructs used in the known data
model into a limited
set of types. Then, we study in this framework formal properties of
scheme translation

We describe the development of a tool called MDM for the
management of multiple models and the translation of database schemes
This tool can be at the basis of an integrated CASE environment supporting the analysis and design of information systems that allows different representations for the same data schemes
We first present a graph-theoretic framework that allows us to formally investigate desirable properties of schema translations
The formalism is based on a classification of the constructs used in the known data model into a limited set of types

In this article, we develop a relational algebra for metadata integration, Federated Interoperable Relational Algebra (FIRA). FIRA has many desirable properties such as compositionality, closure, a deterministic semantics, a modest complexity, support for nested queries, a subalgebra equivalent to canonical Relational Algebra (RA), and robustness under certain classes of schema evolution.

The core of a model theory for generic schema management is developed. This theory has two
distinctive features: it applies to a variety of categories of schemas, and it applies to transformations
of both the schema structure and its integrity constraints. A subtle problem of schema integration is
considered in its general form, not bound to any particular category of schemas. The proposed solution,
as well as the overall theory, is based entirely on schema morphisms that carry both structural and

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

Views as a means to describe parts of a given data collection play an important role in many database applications. In dynamic environments where data is updated, not only information provided by views, but also information provided by data sources yet missing from views turns out to be relevant: Previously, this missing information has been characterized in terms of view complements; recently, it has been shown that view complements can be exploited in the context of data warehouses to guarantee desirable warehouse properties such as independence and self-maintainability.

Many challenging problems facing information systems engineering involve
the manipulation of complex metadata artifacts, or models, such as database
schemas, interface specifications, or object diagrams, and mappings between
models. The applications that solve metadata manipulation problems are
complex and hard to build. The goal of generic model management is to
reduce the amount of programming needed to develop such applications by
providing a database infrastructure in which a set of high-level algebraic
operators, such as Match, Merge, and Compose, are applied to models and

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.

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

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.