Search

Changing a database schema is a fact of life in information systems, as a response to changes inside the enterprise (e.g., new users’ requirements, correction of errors in the current database schema) or outside it (e.g., new regulations, new partners’ requirements). In the database research field, a well-known technique has been proposed for managing schema changes, called schema evolution. It allows the database to survive schema changes by adapting existing data to conform to the new schema. A lot of research efforts addressed the topic of schema evolution, in both conventional (i.e., relational) and advanced (e.g., XML, stream, NoSQL) databases, providing a plethora of heterogeneous approaches and solutions making up a quite large literature. Since there is no research work that extensively deals with different proposals and compares them, the purpose of this paper is to fill this gap by reviewing the available schema evolution literature. For that, first we collected and summarized the contributions of research papers dealing with database schema evolution. Then we organized their presentation in a chronological order, also giving a historical perspective on the topic development. Finally, we defined a list of six comparison criteria (database model, implementation, schema change semantics, schema change propagation, integrity constraints, and software evolution) that have helped us to categorize and compare the different database schema evolution proposals. In sum, our paper (i) provides an overview of the state-of-the-art research approaches on database schema evolution, with tables that compare such approaches based on some proposed criteria, (ii) studies the support of schema evolution in commercial DataBase Management Systems (DBMSs), and (iii) points out some possible future research directions in this area.

When NoSQL database systems are used in an agile software development setting, data model changes occur frequently and thus, data is routinely stored in different versions. The management of versioned data leads to an overhead potentially impeding the software development. Several data migration strategies exist that handle legacy data differently during data accesses, each of which can be characterized by certain advantages and disadvantages. Depending on the requirements for the software application, we evaluate and compare different migration strategies through metrics like migration costs and latency as well as precision and recall. Ideally, exactly that strategy should be selected whose characteristics fulfill service-level agreements and match the migration scenario, which depends on the query workload and the changes in the data model which imply an evolution of the database schema. In this paper, we present a methodology of self-adapting data migration, which automatically adjusts migration strategies and their parameters with respect to the migration scenario and service-level agreements, thereby contributing to the self-management of database systems and supporting agile development. [ABSTRACT FROM AUTHOR]

In order to conduct research effectively, scientists must be able to access, organize, describe, and produce data as part of their daily research activities. While relational databases are well suited to the tasks of describing and organizing scientific metadata and results, the difficulties of using relational database management systems effectively, have resulted in their limited adoption among scientists. In addition, scientific research is changing steadily with new experimental protocols, instruments, and discoveries that determine what data are generated and how they must be described and organized according to a relational schema. Unfortunately, evolving a schema is one of the most difficult aspects of database usage. The conventional data definition and manipulation languages offer relatively low-level programming abstractions to perform complex database evolution tasks, and therefore require specialized technical skills not possessed by most scientists. A simplified means of expressing database evolution operations would reduce the effort for non-expert users of databases. This paper presents a high-level, user-oriented, schema evolution framework built on a formal algebra of schema modification operators. The approach allows introduction of novel operators as motivated by new requirements and is amenable to well established optimization techniques for efficient planning and execution. We also propose a rigorous evaluation methodology for comparing the user effort of database evolution languages, and we introduce a benchmark for evaluating the execution efficiency of schema evolution expressions. We present the framework and its implementation, and we demonstrate its utility in exemplar use cases and a performance evaluation. [ABSTRACT FROM AUTHOR]

Abstract A data integration approach combines data from different sources and builds a unified view for the users. Big data integration inherently is a complex task, and the existing approaches are either potentially limited or invariably rely on manual inputs and interposition from experts or skilled users. SemLinker, an ontology-based data integration system, is part of a metadata management framework for personal data lake (PDL), a personal store-everything architecture. PDL is for casual and unskilled users, therefore SemLinker adopts an automated data integration workflow to minimize manual input requirements. To support the flat architecture of a lake, SemLinker builds and maintains a schema metadata level without involving any physical transformation of data during integration, preserving the data in their native formats while, at the same time, allowing them to be queried and analyzed. Scalability, heterogeneity, and schema evolution are big data integration challenges that are addressed by SemLinker. Large and real-world datasets of substantial heterogeneities are used in evaluating SemLinker. The results demonstrate and confirm the integration efficiency and robustness of SemLinker, especially regarding its capability in the automatic handling of data heterogeneities and schema evolutions.

In this paper, we study the evolution of foreign keys in the context of schema evolution for relational databases. Specifically, we study the schema histories of a six free, open-source databases that contain foreign keys. Our findings verify previous results that schemata grow in the long run in terms of tables. To our surprise, we discovered that foreign keys appear to be fairly scarce in the projects that we have studied and they do not necessarily grow in sync with table growth. In fact, we have observed different "cultures" for the handling of foreign keys, ranging from treating foreign keys as an indispensable part of the schema, in full sync with the growth of tables, to the unexpected extreme of treating foreign keys as an optional add-on that twice resulted in their full removal from the schema of the database. Apart from the behavior of entire schemata, we have also studied the behavior of individual tables. We model the schema of any version of the history as a graph, with tables being nodes and foreign keys being edges. The union of these graphs is called the diachronic graph of the schema and contains all the tables and foreign keys that ever appeared in the schema history. The study of the total degree of tables at the diachronic graph, reveals several patterns. The population of tables with total degree in the range of [0–2] includes almost all the tables that were eventually removed from the schema, as well as the vast majority of survivor tables. These low-degree tables (especially the dead ones) tend to be mostly with zero or very few internal updates in their entire history. At the same time, the few tables with degree higher than 2 are typically born very early in the life of the schema, overwhelmingly survivors, and, unusually active, typically undergoing medium or high update activity. [ABSTRACT FROM AUTHOR]

A data integration approach combines data from different sources and builds a unified view for the users. Big data integration inherently is a complex task, and the existing approaches are either potentially limited or invariably rely on manual inputs and interposition from experts or skilled users. SemLinker, an ontology-based data integration system, is part of a metadata management framework for personal data lake (PDL), a personal store-everything architecture. PDL is for casual and unskilled users, therefore SemLinker adopts an automated data integration workflow to minimize manual input requirements. To support the flat architecture of a lake, SemLinker builds and maintains a schema metadata level without involving any physical transformation of data during integration, preserving the data in their native formats while, at the same time, allowing them to be queried and analyzed. Scalability, heterogeneity, and schema evolution are big data integration challenges that are addressed by SemLinker. Large and real-world datasets of substantial heterogeneities are used in evaluating SemLinker. The results demonstrate and confirm the integration efficiency and robustness of Sem-Linker, especially regarding its capability in the automatic handling of data heterogeneities and schema evolutions. [ABSTRACT FROM AUTHOR]

In the maintenance of software applications, database evolution is one common difficulty. In object-oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspect-oriented programming to support semi-transparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspect-oriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Like all software maintenance, schema evolution is a process that can severely impact the lifecycle of a data-intensive software projects, as schema updates can drive depending applications crushing or delivering incorrect data to end users. In this paper, we study the schema evolution of eight databases that are part of larger open source projects, publicly available through open source repositories. In particular, the focus of our research was the understanding of which tables evolve and how. We report on our observations and patterns on how evolution related properties, like the possibility of deletion, or the amount of updates that a table undergoes, are related to observable table properties like the number of attributes or the time of birth of a table. A study of the update profile of tables, indicates that they are mostly rigid (without any updates to their schema at all) or quiet (with few updates), especially in databases that are more mature and heavily updated. Deletions are significantly outnumbered by table insertions, leading to schema expansion. Delving deeper, we can highlight four patterns of schema evolution. The Γ pattern indicating that tables with large schemata tend to have long durations and avoid removal, the Comet pattern indicating that the tables with most updates are the ones with medium schema size, the Inverse Γ pattern , indicating that tables with medium or small durations produce amounts of updates lower than expected, and, the Empty Triangle pattern indicating that deletions involve mostly early born, quiet tables with short lives, whereas older tables are unlikely to be removed. Overall, we believe that the observed evidence strongly indicates that databases are rigidity-prone rather than evolution-prone. We call the phenomenon gravitation to rigidity and we attribute it to the implied impact to the surrounding code that a modification to the schema of a database has. [ABSTRACT FROM AUTHOR]

In this paper, we present the findings of a large study of the evolution of the schema of 195 Free Open Source Software projects. We identify families of evolutionary behaviors, or taxa, in FOSS projects. A large percentage of the projects demonstrate very few, if any, actions of schema evolution. Two other taxa involve the evolution via focused actions, with either a single focused maintenance action, or a large percentage of evolution activity grouped in no more than a couple interventions. Schema evolution also involves moderate, and active evolution, with very different volumes of updates to the schema. We also investigate how the different taxa relate to measurable properties of schema evolution, specifically, duration of schema and project updates, activity volume, and heartbeat. We show that although different taxa have practically very similar duration, the evolutionary characteristics differ in analogy to the "active" character of each taxon. Moreover, by observing certain similarities in the measurable properties of the taxa, we take the opportunity to introduce super taxa, which complement the previous taxonomy with the groupings of the aforementioned taxa in terms of overall profile similarity, resulting in a more concise and intuitive taxonomy, providing a cleaner separation of evolution measures. Finally, we show that schema evolution is frequently, a time-concentrated activity. • We report on the largest study of schema evolution ever, over 195 FOSS projects. • The absence of schema evolution is more prevalent than its presence. • We introduce 6 families of evolutionary behaviors, or, taxa of schema evolution. • Evolution measures differ in analogy to the "liveliness" of each taxon. • We group taxa into a clean hierarchy of super taxa with well-separated higher levels. • We show that typically schema evolution is an activity of high time-concentration. [ABSTRACT FROM AUTHOR]

Like all software systems, databases are subject to evolution as time passes. The impact of this evolution can be vast as a change to the schema of a database can affect the syntactic correctness and the semantic validity of all the surrounding applications. In this paper, we have performed a thorough, large-scale study on the evolution of databases that are part of larger open source projects, publicly available through open source repositories. Lehman׳s laws of software evolution, a well-established set of observations on how the typical software systems evolve (matured during the last forty years), has served as our guide towards providing insights on the mechanisms that govern schema evolution. Much like software systems, we found that schemata expand over time, under a stabilization mechanism that constraints uncontrolled expansion with perfective maintenance. At the same time, unlike typical software systems, the growth is typically low, with long periods of calmness interrupted by bursts of maintenance and a surprising lack of complexity increase. [ABSTRACT FROM AUTHOR]

In the context of model-driven development of database applications with UML, the (usually relational) database schema is obtained automatically from the application's structural (class) UML model. Changes in requirements often lead to modifications of the application's structural model. Such changes, in turn, have to be propagated to the underlying database schema. Very often, especially when the system is in production with a large volume of users' live data, the data is considered to be valuable enough to be preserved through these changes. This paper describes an approach to cope with the problem of model evolution with the ultimate requirement to preserve the data stored in the database. The algorithm interactively determines differences between structural UML models before and after the changes and resolves those differences into transformations in the relational database domain. [ABSTRACT FROM AUTHOR]

Context-aware data tailoring studies the means for the system to furnish the users, at any moment, only with the set of data which is relevant for their current context. These data may be from traditional databases, sensor readings, environmental information, close-by people, points of interest, etc. To implement context-awareness, we use a formal representation of a conceptual context model , used to design the context schema , which intensionally represents all the contexts in which the user may be involved in the considered application scenario. Following this line of thought, in this paper we develop a formal approach and the corresponding strategy to manage the evolution of the context schema of a given context-aware application, when the context perspectives initially envisaged by the system designer are not applicable any more and unexpected contexts are to be activated. Accordingly, when the context schema evolves also the evolution of the corresponding context-aware data portions must be taken care of. The aim of this paper is thus to provide the necessary conceptual and formal notions to manage the evolution of a context schema in the perspective of data tailoring: after introducing a set of operators to manage evolution and proving their soundness and completeness, we analyze the impact that context evolution has on the context-based data tailoring process. We then study how sequences of operator applications can be optimized and finally present a prototype validating the feasibility of the approach. [ABSTRACT FROM AUTHOR]

Database reverse engineering (DRE) has traditionally been carried out by considering three main information sources: (1) the database schema, (2) the stored data, and (3) the application programs. Not all of these information sources are always available, or of sufficient quality to inform the DRE process. For example, getting access to real-world data is often extremely problematic for information systems that maintain private data. In recent years, the analysis of the evolution history of software programs have gained an increasing role in reverse engineering in general, but comparatively little such research has been carried out in the context of database reverse engineering. The goal of this paper is to contribute to narrowing this gap and exploring the use of the database evolution history as an additional information source to aid database schema reverse engineering. We present a tool-supported method for analyzing the evolution history of legacy databases, and we report on a large-scale case study of reverse engineering a complex information system and curate it as a benchmark for future research efforts within the community. [ABSTRACT FROM AUTHOR]

This paper examines the problem of conceptual dependence, the coupling of software applications׳ internal structures and logic with their underlying conceptual models. Although conceptual dependence is almost universal in information system design, it produces a range of unintended negative consequences including system inflexibility and increased maintenance costs. Many information systems contain components, such as database tables and classes, whose design reflects the entity types and relationships in underlying, domain-oriented conceptual models. When the models change, work is involved in altering the software components. For example, an e-commerce system might include tables and classes representing product types, customers and orders, with associated code in methods, stored procedures and other scripts. The structure of the entity types and their relationships will be implicit in the tables, classes and code, coupling the system to its conceptual model. Any change to the model (such as the introduction of a new entity type, representing order lines) invalidates existing structures and code, causing rework. In large systems, this rework can be time-consuming and expensive. Research shows that schema change is common, and that it contributes significantly to the high cost of software maintenance. We argue that much of the cost may be avoidable if alternative design strategies are used. The paper describes an alternative design approach based on the principle of conceptual independence, which can be used to produce adaptive information systems (AIS). It decouples the internal structures and logic of information systems from the domain-specific entity types and relationships in the conceptual models they implement. An architecture for AIS is presented which includes soft schemas (conceptual models stored as data), an end-user conceptual modelling tool, a set of archetypal categories (predefined semantic categories), and an adaptive data model which allows data to be stored without conceptual dependence. The archetypal categories allow domain-specific run time behaviour to be provided, despite the absence of domain-specific software structure and logic. An advantage of AIS over conventionally-designed applications is that each AIS can be used in a wide variety of domains. AIS offer the prospect of significantly reduced maintenance costs, as well as increased scope for the development and modification of systems by end users. Work to date on implementation of the AIS architecture is discussed, and an agenda for future research is outlined including development and evaluation of a fully-featured AIS. The paper discusses challenges to be overcome and barriers to adoption. [ABSTRACT FROM AUTHOR]

The paper presents a: a) brief overview and analysis of existing approaches to the data warehouse (DW) evolution problem, and b) detailed description of the research idea for the DW evolution problem (primarily intended for structured data sources and realizations with relational database engines). We observe the DW evolution problem as a double issue - from the DW perspective, and from the master data management (MDM) perspective. The proposed general solution will include a Data Vault (DV) model based metadata repository that will integrate the DW data and metadata with the MDM data and metadata. This historicized metadata repository will manage schema versions and support schema changes. We believe this integration will: a) increase the quality of data in the Enterprise Data Warehouse (EDW), b) increase the quality of the metadata in the EDW, and c) increase the simplicity and efficiency of the DW and the MDM schema evolution. [ABSTRACT FROM AUTHOR]

There are many problems associated, when we upgrade our product database schema to next version. Many times it is found that there is data corruption or we find that data integrity and consistency is lost. There are many solutions/methods, but each method has its own drawback to overcome these problems. We have suggested an incremental methodology to upgrade a database schema from one version to next version having no data corruption and maintaining the database consistency and integrity. [ABSTRACT FROM AUTHOR]

Supporting database schema evolution represents a long-standing challenge of practical and theoretical importance for modern information systems. In this paper, we describe techniques and systems for automating the critical tasks of migrating the database and rewriting the legacy applications. In addition to labor saving, the benefits delivered by these advances are many and include reliable prediction of outcome, minimization of downtime, system-produced documentation, and support for archiving, historical queries, and provenance. The PRISM/PRISM++ system delivers these benefits, by solving the difficult problem of automating the migration of databases and the rewriting of queries and updates. In this paper, we present the PRISM/PRISM++ system and the novel technology that made it possible. In particular, we focus on the difficult and previously unsolved problem of supporting legacy queries and updates under schema and integrity constraints evolution. The PRISM/PRISM++ approach consists in providing the users with a set of SQL-based Schema Modification Operators (SMOs), which describe how the tables in the old schema are modified into those in the new schema. In order to support updates, SMOs are extended with integrity constraints modification operators. By using recent results on schema mapping, the paper (i) characterizes the impact on integrity constraints of structural schema changes, (ii) devises representations that enable the rewriting of updates, and (iii) develop a unified approach for query and update rewriting under constraints. We complement the system with two novel tools: the first automatically collects and provides statistics on schema evolution histories, whereas the second derives equivalent sequences of SMOs from the migration scripts that were used for schema upgrades. These tools were used to produce an extensive testbed containing 15 evolution histories of scientific databases and web information systems, providing over 100 years of aggregate evolution histories and almost 2,000 schema evolution steps. [ABSTRACT FROM AUTHOR]

To guarantee a complete data history in temporal databases, database management systems have to manage both evolution of schema over time, through their versioning, and evolution of data defined under different schema versions. This paper proposes a new approach for schema versioning in multi-temporal databases. It allows an efficient management of schema versions and their underlying data, through a smooth conversion of the temporal database. When creating a new schema version, the basic idea consists in forbidding 1) any automatic transfer of data defined under previous schema versions to this new version, in order to avoid data loss and ambiguousness in the interpretation of temporal intervals of data, and 2) any change in the structures of previous schema versions, in order to permit to the legacy applications to remain operational after this schema evolution. [ABSTRACT FROM AUTHOR]

Abstract: The Basic-Table combined with Extension-Table (BT&ET) layout has become the popular data storage architecture for SaaS currently. For the sake of improving the processing efficiency we improve the BT&ET layout, and migrate some tenants’ frequently accessed extension fields into the basic table based on the tenants’ constantly need on data access. With the development of cloud computing, Multi-Tenant data need to be stored in multiple data nodes. When tenant''s data storage schema evolution happens, all data nodes hava to do data migration simultaneously and tenants may perceive the influence. In order to minimize the costs and negative load of schema evolution we propose the Multi-Version metadata technology. Tenant''s data on each data node may contain different version metadata, and schema envolution can run asynchronously. We carry out experiments and the results figure out that the workload decreases significantly. [Copyright &y& Elsevier]

We consider the problem of XML Schema evolution. In the ever-changing context of the web, XML schemas continuously change in order to cope with the natural evolution of the entities they describe. Schema changes have important consequences. First, existing documents valid with respect to the original schema are no longer guaranteed to fulfill the constraints described by the evolved schema. Second, the evolution also impacts programs, manipulating documents whose structure is described by the original schema. We propose a unifying framework for determining the effects of XML Schema evolution both on the validity of documents and on queries. The system is very powerful in analyzing various scenarios in which forward/backward compatibility of schemas is broken, and in which the result of a query may no longer be what was expected. Specifically, the system offers a predicate language that allows one to formulate properties related to schema evolution. The system then relies on exact reasoning techniques to perform a fine-grained analysis. This yields either a formal proof of the property or a counter-example that can be used for debugging purposes. The system has been fully implemented and tested with real-world use cases, in particular with the main standard document formats used on the web, as defined by W3C. The system precisely identifies compatibility relations between document formats. In case these relations do not hold, the system can identify queries that must be reformulated in order to produce the expected results across successive schema versions. [ABSTRACT FROM AUTHOR]

A broad variety of data is available in distinct heterogeneous sources, stored under different formats: database formats (in relational and object-oriented models), document formats (SGML/XML), browser formats (HTML), message formats, etc. The integration of such data is increasingly important for modern information systems applications such as data warehousing, data mining, and web applications. This is realized by providing a uniform view of data sources (called mediation schema or global schema) and defining a set of queries (called mediation queries or mediation mappings) which define objects of the mediation schema. One of the important problems that merit consideration is the impact of schema evolution on mediation queries. Mappings left inconsistent by a schema change have to be detected and updated. In particular, one source may be removed from the system because it provides always obsolete information or because it is unavailable. In this case it is necessary to update the inconsistent mappings. In this paper, we study the removal of a source from an integration system and show how to correctly update the mappings between the mediation schema and the distributed sources after this change, in the context of the global-as-view approach (each relation of the global schema is expressed as a view on the data source). [ABSTRACT FROM AUTHOR]

In genetic programming (GP), evolving tree nodes separately would reduce the huge solution space. However, tree nodes are highly interdependent with respect to their fitness. In this paper, we propose a new GP framework, namely, instruction-matrix (IM)-based GP (IMGP), to handle their interactions. IMGP maintains an IM to evolve tree nodes and subtrees separately. IMGP extracts program trees from an IM and updates the IM with the information of the extracted program trees As the IM actually keeps most of the information of the schemata of GP and evolves the schemata directly, IMGP is effective and efficient. Our experimental results on benchmark problems have verified that IMGP is not only better than those of canonical GP in terms of the qualities of the solutions and the number of program evaluations, but they are also better than some of the related GP algorithms. IMGP can also be used to evolve programs for classification problems. The classifiers obtained have higher classification accuracies than four other GP classification algorithms on four benchmark classification problems. The testing errors are also comparable to or better than those obtained with well-known classifiers. Furthermore, an extended version, called condition matrix for rule learning, has been used successfully to handle multiclass classification problems. [ABSTRACT FROM AUTHOR]

An XML schema is a set of rules for defining the allowed sub-elements of any element in an XML document. These rules use regular expressions to define the language of the element''s children. Updates to an XML schema are updates to the regular expressions defined by the schema rules. We consider an interactive, data administration tool for XML databases. In this tool, changes on an XML schema are activated by updates that violate the validity of an XML document. Our schema validator is a Datalog program, resulting from the translation of a given XML schema. Changing the schema implies changing the validator. The main contribution of this paper is an algorithm allowing the evolution of XML schemas. This algorithm is based on the computation of new regular expressions to extend a given regular language in a conservative way, trying to foresee the needs of an application. A translation function from schema constraints to Datalog programs is introduced. The validation of an XML tree corresponds to the evaluation of the Datalog program over the tree. Our method allows the maintenance of the Datalog program in an incremental way, i.e., without redoing the entire translation. [Copyright &y& Elsevier]

Abstract: Reference models, often called core models are developed in various application domains. Until now, no computational support exists for the task of verifying the conformity between such core models and their domain models. The approach developed at Bamberg University uses Semantic Web technologies to examine whether or not a domain model is a derivation of a core model. This ontology-based conformity verification supports an iterative modeling process in which core or domain models are modified. Inference services as provided by ontologies can be used to analyze the relationships between core and domain models. For example, it is possible to formally prove which specific relations hold between two types of models and compare the result with the intentions of the domain experts involved in the modeling. As a consequence, knowledge not explicitly represented is revealed. In case that the domain model does not conform to the core model, an interpretation of the inference results is provided in ordinary language giving the domain experts hints on how to modify either the core model, the domain model or both. We evaluated our approach by applying it to a core model and a domain, hence national model from the cadastral domain. Conformity was verified between the core cadastral model proposed by [Lemmen, C., van der Molen, P., van Oosterom, P., Ploeger, H., Quak, W., Stoter, J., et al. (2003). A modular standard for the cadastral domain. In Proceedings of digital earth 2003: Information resources for global sustainability: knowledge, networks, technology, economy, society, natural and human resources, policy and strategy. Brno, Czech Republic, pp. 108–117] and the Greek cadastral model [Tzani, A. (2003). Object-oriented modeling of the Greek Cadastre. Master’s thesis, School of Rural and Surveying Engineering of Aristotle University of Thessaloniki], which both are results of research activities related to the European COST Action G9 “Modeling Real Property Transactions”. Although our approach to conformity verification was only evaluated with the cadastral models, it can be used for conformity verification in various applications domains due to its generality. [Copyright &y& Elsevier]

Views over distributed information sources, such as data warehouses, rely on the stability of the schemas of underlying databases. In the event of meta data changes in the sources, such as the deletion of a table or column, such views may become undefined. Using meta data about information redundancy, views can be evolved as necessary to remain well defined after source meta data changes.Previous work in view synchronization focused only on deletions of schema elements. We now offer an approach that makes use of additions also. Our algorithm returns view definitions to previous versions by using knowledge about the history of views and meta data. This technology enables us to adapt views to temporary meta data changes by canceling out opposite changes. It also allows undo/redo operations on meta data. Last, in many cases, the resulting evolved views even have an improved information quality. In this paper, we give a formal taxonomy of schema and constraint changes and a full description of the proposed history-driven view-synchronization algorithm for this taxonomy. We also prove the history-driven view-synchronization algorithm to be correct. Our approach falls in the global-as-view category of data integration solutions but, unlike prior solutions in this category, it now also deals with changes in the information space rather than requiring source schemas to remain constant over time. [ABSTRACT FROM AUTHOR]

Abstract: In this paper we define the Temporal and Versioning Model for Schema Evolution (TVSE), a model that uses time and version concepts to manage dynamic schema evolution in object-oriented databases. The proposed model is able to manage the schema evolution process considering: schema versioning, schema modification, change propagation and data manipulation. TVSE differs from other schema evolution models by enabling the homogeneous and simultaneous management of the evolution history concerning both intentional and extensional databases. Besides defining the model, we also propose a language to derive and modify schema versions, and also to update data associated with them, creating either new object versions or just keeping the history of these data modifications. We provide an operational semantics for this language which is an essential step towards for establishing the preservation of complex time integrity constraints. [Copyright &y& Elsevier]

Like any other database application, object database applications are subject to evolution. Evolution, however, is a critical requirement in object-oriented databases as it is a fundamental characteristic of complex applications such as computer-aided design and manufacturing (CAD/CAM) and office information systems. Object-oriented databases are inherently suited to supporting such applications. In this paper we present a database evolution taxonomy for object-oriented databases. We describe a conceptual database model and use it to define the taxonomy. We also present the various invariants and rules governing the various evolution operations. The execution sequence of rules is described. An implementation of the database model and the evolution taxonomy in the Semi-Autonomous Database Evolution System (SADES), is discussed. The implementation employs aspect-oriented programming techniques to provide a flexible means of transforming objects upon evolution, and implementing some application-specific evolution primitives. A case study compares the evolution taxonomy with existing evolution approaches. The comparison demonstrates that the taxonomy and its corresponding implementation in SADES provide improved coverage of the fundamental evolution operations to which an object database might be subjected. At the same time, erosion of the database structure is avoided by maintaining a coherent and comprehensible view of historical changes. Copyright © 2005 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

As ontology development becomes a more ubiquitous and collaborative process, ontology versioning and evolution becomes an important area of ontology research. The many similarities between database-schema evolution and ontology evolution will allow us to build on the extensive research in schema evolution. However, there are also important differences between database schemas and ontologies. The differences stem from different usage paradigms, the presence of explicit semantics and different knowledge models. A lot of problems that existed only in theory in database research come to the forefront as practical problems in ontology evolution. These differences have important implications for the development of ontology-evolution frameworks: The traditional distinction between versioning and evolution is not applicable to ontologies. There are several dimensions along which compatibility between versions must be considered. The set of change operations for ontologies is different. We must develop automatic techniques for finding similarities and differences between versions. [ABSTRACT FROM AUTHOR]

Process-oriented support of collaborative work is an important challenge today. At first glance, Workflow Management Systems (WfMS) seem to be very suitable tools for realizing team-work processes. However, such processes have to be frequently adapted, e.g., due to process optimizations or when process goals change. Unfortunately, runtime adaptability still seems to be an unsolvable problem for almost all existing WfMS. Usually, process changes can be accomplished by modifying a corresponding (graphical) workflow (WF) schema. Especially for long-running processes, however, it is extremely important that such changes can be propagated to already running WF instances as well, but without causing inconsistencies and errors. The paper presents a general and comprehensive correctness criterion for ensuring compliance of in-progress WF instances with a modified WF schema. For different kinds of WF schema changes, it is precisely stated, which rules and which information are needed at mininum for satisfying this criterion. [ABSTRACT FROM AUTHOR]