Schema Evolution publication categorizer

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.

Schema evolution is an unavoidable consequence of the application development lifecycle. The two primary schemas in an application, the client conceptual object model and the persistent database model, must co-evolve or risk quality, stability, and maintainability issues. We present MoDEF, an extension to Visual Studio that supports automatic evolution of object-relational mapping artifacts in the Microsoft Entity Framework.

In this paper we present a formal model for the support of temporal schema versions in object-oriented databases. Its definition is partially based on a generic (ODMG compatible) object model and partially introduces new concepts. The proposed model supports all the schema changes which are usually considered in the OODB literature, for which an operational semantics and a formal analysis of their correct behaviour is provided.

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.

Schema evolution is the process of applying changes to a schema in a consistent way and propagating these changes to the instances while the database is in operation. In this process there are two problems to consider: semantics of change and change propagation. In this paper, we study the problem of the semantics of change for the schema evolution defined with the ODMG object model.

In this paper, we propose a schema versioning mechanism to manage the schema evolution in temporal object-oriented databases. The schema evolution management uses an object-oriented data model that supports temporal features and versions definition - the Temporal Versions Model - TVM. One interesting feature of our proposal is that TVM is used to control not only the schema versioning, but also the storage of extensional database and propagation of the changes performed on the objects.

The multiobject mechanism is a pertinent way to implement specialization in an object database and differs from the classical mechanism used in most object-oriented database systems. It supports multiple instantiation, automatic classification and object migration. Consequently it is well suited to take into account schema evolution. It makes schema changes more pertinent, easier to implement, and less expensive than with the classical implementation of specialization indeed. The multiobject mechanism is implemented in the F2 database system which supports schema evolution.

Currently, existing Object Database Systems (ODBSs) perform schema changes by means of primitives closely related to their
respective data model. Software Engineering (SE) applications, Object
Methodologies (OM) and designers building up object database schemata
require a more abstract level. This paper addresses new facilities for updating a schema filling the gap between object design and object pro-
gramming.
A set of advanced primitives, so-called \"High Level Primitives\", is presented to cope with these requirements. The semantics of these new

The issues of schema evolution and temporal object models are generally considered to
be orthogonal and are handled independently. This is unrealistic because to properly model
applications that need incremental design and experimentation (such as CAD, software design
process), the evolutionary histories of the schema objects should be traceable. In this paper we
propose a method for managing schema changes by exploiting the functionality of a temporal
object model. The result is a uniform treatment of schema evolution and temporal support for

Relationships have been repeatedly identified as an important object-oriented modeling construct. Today most emerging modeling standards such as the ODMG object model and UML have some support for relationships. However while dealing with schema evolution, OODB systems have largely ignored the existence of relationships. We are the first to propose comprehensive support for relationship evolution.

An approach to schema modification management is presented which also takes into concern that alternative schema perspectives seems to be needed, in addition to revision-like changes. The primary goal is to support change transparency when the schema is modified, such that existing application programs and objects need not be affected by changes to the schema. The approach is based on explicitly distinguishing Type (external interface of objects) and Class (object implementation and...

More than ever before schema transformation is a prevalent problem that needs to be addressed to accomplish for example the migration of legacy systems to the newer OODB systems, the generation of structured web pages from data in database systems, or the integration of systems with different native data models. Such schema transformations are typically composed of a sequence of schema evolution operations. The execution of such sequences can be very time-intensive, possibly requiring many hours or even days and thus effectively making the database unavailable for unacceptable time spans.

This paper addresses the design of a schema evo-
lution framework enabling an efficient management of
object versions. This framework is based on the adap-
tation and extension of two main schema evolution
approaches, that is the approaches based on schema
modification and those based on schema versioning.
The framework provides an integrated environment to
support different levels of adaptation (such as, modifi-
cation and versioning at the schema level, conversion,
object versioning, and emulation at the instance level).
In addition, we introduce the concept of class/schema

This paper addresses the design of an integrated framework for managing schema evolution. This framework is based on the adaptation and extension of two main schema evolution approaches, namely schema modification and schema versioning. The proposed framework provides an integrated environment to support different database evolution techniques (such as, modification and versions at the schema level, conversion, object versioning, and screening at the instance level).

In this paper we address the problem of schema evolution in object-oriented database systems. Most currently available database prototypes either completely lack schema evolution facilities, or offer a restricted set of special purpose schema evolution operators supporting simple schema changes. Our approach is different. We consider schema objects as objects like others and have the meta schema fully available at run-time. Thus any operator of our object manipulation and query algebra can be applied to meta-objects ..

A `reasonable' minimal set of primitives for updating an object-oriented (O2) database schema is defined and the problems which need to be solved in order to obtain a usable schema update mechanism are shown. The distinction between structural and behavioral consistency for the O2 system is described in some detail and it is demonstrated how updates could be performed by invoking an interactive tool. Updates are classified in three categories. Each category is explained in detail.

Version control is one of the most important functions which need to be supported in integrated computer-aided design (CAD) systems. In this paper we address a broad spectrum of semantic and operational issues in version control for a public/private distributed architecture of CAD systems. The research issues we address include the semantics of version creation and manipulation, version naming and name binding, and version change notification. We develop solutions to these issues under a unifying framework, and discuss implementation and application interface issues.

In engineering applications, multiple copies of object descriptions have to coexist in a single database. A scheme is proposed that enables users to explicitly deal with these object versions. After introducing a basic version model, the problem of rerouting interobject references on the creation of new versions is solved by providing generic references and user-specific environments. Logical version clusters are introduced that allow for the meaningful grouping of versions. Some remarks on implementation and a comparison with other approaches are also included

Object-oriented database systems ususally exhibit specific advantages over traditional database management systems and programming languages. Among them stand the ease of writing, maintaining and debugging application programs, code modularity, inheritance, persistency and sharability. Of particular interest to software engineering and computer-aided design applications is also the ability to dynamically change the object definitions and the opportunity to define incrementally composite objects.

Object-oriented databases are said to support evolution and incremental development. On the schema level, a firm restriction in this evolution is that it can only be done by evolving class hierarchies downwards by subclassing. We show a unified approach to class evolution in object-oriented databases, where class hierarchies are allowed to grow in all directions, covering for evolution situations like generalisation, specialisation, and class versioning. We show how to make the evolution ...

We examine the problem of type evolution in an object-oriented database environment. Type definitions are persistent objects in the database and as such may be modified and shared. The effects of changing a type extend to objects of the type and to programs that use objects of the type. We propose a solution to the problem through an extension of the semantic data model.A change in the interface defined by a type may result in errors when programs use new or old objects of the type.

Providing support forschema evolution allows existing databases to be adjusted for varying roles over time. This paper reflects on existing evolution support schemes and introduces a more general and functional mechanism to support schema evolution andinstance adaptation for centralized and distributed object-oriented database systems. Our evolution support scheme is distinguished from previous mechanisms in that it is primarily concerned with preserving existing database objects and maintaining compatibility for old applications, while permitting a wider range of evolution operations.

We are concerned by schema evolution in Object Oriented Databases (OODB) that is processed by a modification on the
classes on the schema. We present a new categorization of the different modifications in three categories : primitive,
composite and complexe modifications. On this basis, we propose a method by decomposition for addressing conceptual
schema evolution: real-life, complex schema modifications are solved by decomposition into simpler, well-known and
controlled modifications, called composites, which in turn may be reduced to so-called primitives. A key step in making

While the contents of databases can be easily changed, their organization is typically extremely rigid. Some databases relax the rigidity of database organization somewhat by supporting simple changes to individual schemas. As described in this paper, OTGen supports not only more complex schema changes, but also database reorganization. A database administrator uses a declarative notation to describe mappings between objects created with old versions of schemas and their corresponding representations using new versions.

Object-oriented database systems (OODBMS) offer powerful modeling concepts as required by advanced application domains like CAD/CAM/CAE or office automation. Typical applications have to handle large and complex structured objects which frequently change their value and their structure. As the structure is described in the schema of the database, support for schema evolution is a highly required feature. Therefore, a set of schema update primitives must be provided which can be used to perform the required changes, even in the presence of populated databases and running applications.