This paper presents a framework for evolving relation schemas that is based on conditional schema changes and tuple versioning. With each tuple a recorded schema and a conceptual schema is associated. This allows for a simple and semantically clean solution to the problem of schema mismatches that arise when the schema of a database is changed and some data no longer fits the schema. Specifically, no data needs to be migrated to the new schema, and no special null values are required. We precisely define evolving schemas in terms of schema segments and corresponding attribute mappings, present an algorithm to compute answers to queries over evolving schemas, and prove that the query answers consider the maximal set of schema segments consistent with the evolving schema.
The current research attempts to model a technique for managing conflicts within an integrated database. An integrated database being a database whose schema is an integration of several external database schemas, independent of each other. The independence of the systems allows conflicting values to be entered into the same data objects. For example, one system may hold the value of female for a specific data object where as another may hold male. The conflict is only discovered when the data objects are brought to the integrated database, and then there is need to resolve the conflict. A technique to manage conflicts is developed based on version management, used in temporal databases, and the log-file approach used in more conventional technologies. The model combines temporal database tools with distributed database management tools. Thus it obtains greater flexibility than existing replication and log-file techniques and is more economic in record volume than the temporal approach.
In this paper we consider the construction of a dimensional data warehouse. The warehouse is built beginning with the first data mart and proceeding in an iterative manner constructing one mart at a time. In this way the warehouse is seen to evolve over time. This evolutionary process is necessary due to the complexity of data stores, relationships, transformations, and the processing involved. In this paper we consider the problem of identifying the next data mart to construct and present a tool based on Quality Function Deployment for use in the planning stages.
In this paper we study the logical and computational properties of schema evolution and versioning support in object-oriented databases. To this end, we present the formalisation of a general model for an object base with evolving schemata and define the semantics of the provided schema change operations. We will then sketch how the encoding of such a framework in a suitable Description Logic will allow the introduction and solution of interesting reasoning tasks at global database and single schema version levels.
Schema evolution is an important component of advanced information systems such as objectbase management systems. These systems typically support volatile and complex application domains that include engineering design, CAD/CAM, multimedia, and geo-information systems. The schema of these applications must be able to evolve along with the changing environment. There are two problems to consider in schema evolution: (i) semantics of change and (ii) change propagation. The first deals with the effects of the schema change on the overall type system. For example, the deletion of a property in a type affects the subtypes inheriting that property. Our previous work has introduced a sound and complete axiomatic model to deal with the semantics of change problem. The second problem deals with the techniques for propagating schema changes to the underlying objects. For example, the addition of an attribute to a type requires additional memory to be allocated to the objects so that values for the attribute may be stored. The first step of change propagation is to identify the affected objects. Subsequent steps carry out the actual changes. This paper deals with the first step by extending the axiomatic model with semantics to determine a sound and complete set of objects affected by a schema change. The extended model can be used with any method for carrying out the changes such as the conversion, screening, and filtering approaches proposed in the literature.
Today, information systems are essential parts of large organizations. Since such kinds of systems have a very long life-span, they have to be adapted to new changing requirements occurring during their lifetime. Evolution must be regarded not only at the object state level, but also at the object behavior level. Especially, the explicit handling of (behavior) evolution on the conceptual level is necessary. For that, we introduce the notion of evolving objects as basic building blocks of information systems. The behavior of such an object is divided into a rigid and an evolving part. The rigid behavior is ideally stable for the whole life-span of the object; the evolving behavior can be changed dynamically at runtime. In this paper, we present an extended specification framework for modeling evolving objects. Particularly, this framework provides the basis to explicitly specify behavior evolution.
The object model represents the core of an OODB system. Any change in the object model such as the addition of an association or aggregation relationship affects many sub-systems including the schema evolution system. Under the current tightly-coupled database architecture, updating the object model is an extremely expensive undertaking for a database vendor both in terms of time and resources. Adding a new construct to the object model impacts the schema evolution system in two ways: (1) the new construct requires a new set of schema evolution primitives to enable its evolution; and (2) existing schema evolution primitives must be modified to assure that they conform to the new constraints of the new object model. One traditional approach to address this is to manually change all affected software, a time consuming task. We present an alternate two-prong solution. We first decouple the constraints from the schema evolution primitives and secondly we provide a mechanism that allows for the declarative definition of both the primitives and the constraints. We show via examples that we can reduce the software evolution cost of the schema evolution component completely for semantic extensions to the object model and can partially reduce the cost for most other new modeling constructs.
It is generally believed that a well-designed Conceptual Schema will remain stable over time. However, current literature rarely addresses how such stability should be observed and measured in the operational business environment with evolving information needs and database structures. This paper sets up a framework for stability of conceptual schemas and proceeds to develop a set of metrics from it. The metrics are based on straightforward measurements of conceptual features. The validity of the set of metrics is argued here from theory, operational validity may be demonstrated by a longitudinal case study into the evolution of conceptual schemas. The main contribution of this paper is the realization that the measurement of conceptual schema stability is an essential step for understanding and improving current theories and best-practices for designing high-quality schemas that will stand the test of time.
Many applications in Object Databases (ODB), for example, schema management tools, CASE tools, database development tools and integration wrappers, need extensive queries over both application data as well as metadata. However queries over metadata via OQL, a de-facto standard for object query languages defined for the ODMG 2.0 Object Model, are tied to low-level implementation details of the underlying schema repository of the database system. Hence, they are neither portable nor easily usable, requiring the application developer to have detailed knowledge of the proprietary structure of the schema repository. In this paper, we propose an extension of OQL, called MetaOQL, to address this limitation. Our proposition of MetaOQL offers several benefits: (1) it is a natural extension of OQL in terms of both its syntax and semantics; (2) it removes the dependency of metadata queries on the particular schema repository, hence providing uniformity and portability of metadata queries across different ODBs; (3) it supports transparent navigation over the metadata thus offering ease of use; (4) unlike OQL, it hides metadata querying details from the users hence the queries can be simplified and more easy to read and understand. We have also investigated implementation strategies for MetaOQL. In particular, we propose a translation strategy from MetaOQL to OQL as a preferable solution compared to development of a special-purpose MetaOQL processor. The translation strategy offers the advantage that the MetaOQL queries can be retargeted to work on top of any existing ODB engine equipped with OQL with minimal effort. Furthermore, all OQL query optimization strategies can thus still be brought to bear in our extended system.
A database schema denotes the description of the structure and behavior of a database. Straightforwardly, (database) schema evolution refers to changes of the database schema that occur during the lifetime of the corresponding database. It particularly refers to changes of schema elements already stored in the database.
With the increasing complexity of systems being modeled, analysis & design move towards more and more abstract methodologies. Most of them rely on metamodeling tools that employ multi-view models and the four-layer metamodeling architecture. Our idea is to use the metamodeling approach to classify and to constraint the possible evolutions of an information system with the effect to improve both detection of evolution conflicts and disciplined reuse. Within the domain of UML metamodeling, a refinement of the metamodel-level classification is proposed that includes bases for defining a metric of the evolution (in terms of distance between metamodels).
For adequately specifying and rapid-prototyping concurrent information systems, we proposed in [AS99] a new form of object oriented (OO) Petri nets. Referred to as Co-nets, this approach allows in particular to conceive such systems as complex autonomous yet cooperating components. Moreover, for coping with intrinsic dynamic evolution in such systems, we have straightforwardly extended this proposal by introducing notions of meta-places, non-instantiated transitions and a two-step evaluated inference rule [Aou00]. The purpose of this paper is to tackle with another crucial dimension characterizing real-world information systems, namely static and dynamic integrity constraints. For this aim, we propose to associate with each component a ‘constraints’ class. To enforce such constraints, we propose an appropriate ‘synchronization’ inference rule that semantically relates ‘constraints’ transitions with intrinsically dependent ones in the associated component. For a more flexible consistency management we enrich this first proposal by an adequate meta-level, where constraints may be dynamically created, modified or deleted. Finally, we show how this proposal covers a large number of constraint subclasses, including life-cycle based constraints and constraints based on complex derived information as view classes.
Nowadays formal specification techniques have become popular in the development process of many kinds of software systems. Since many technical scenarios are based on computer control, their software implementations also depend on previously established formal descriptions. Additionally, technical information systems such as production control facilities often have a long life span. Due to this fact, dynamic changes become increasingly likely. For example, these changes may be induced by introduction of new laws, altered production goals, human interactions, or any other kind of external influences. However, these changes sometimes require an alteration of the software. To fit the implementation, its formal specification (if present) has to be adapted appropriately. Ordinary specification methods do not permit a post-implementation change in the specification itself but rather an afresh specification effort throwing away the current formal description. Since the necessary changes would frequently result in minor adaptations in the specification, this situation is very unsatisfactory. To avoid or reduce this re-specification effort, we are working on extensions of established specification techniques which can cover adaptive specifications. The remainder of this paper is organized as follows. Section 1 introduces our project and presents a simple classification of adaptive specifications. In Section 2 we briefly present the main issues of the case study and motivate adaptive specifications. Subsequently we suggest some syntactical extensions of TROLL in Section 3. And finally, Section 4 gives an outlook on future work in this project.
In this article we extend previous work on the development of logical foundations for the specification of the dynamics of databases. In particular, we deal with two problems. Firstly, the derivation of active rules that maintain the consistency of the database by triggering repairing actions. Secondly, we deal with the correct integration of the specification of the derived rules into the original specification of the database dynamics. In particular, we show that the expected results are achieved. For instance, the derived axiomatization includes, at the object level, the specification that repairing action executions must be enforced whenever necessary.
In this paper we introduce inheritance in deductive object databases and define an operator for hierarchically composing deductive objects with state evolution capabilities. Evolution of such objects models the expected transactional behavior while preserving many important features of deductive databases. Deductive objects can be organized in ISA schemas where each object may inherit or redefine the rules defined in other objects. The resulting inheritance mechanism handles both the deductive and the update/transactional issues. Our framework accommodates several types of inheritance such as overriding, extension, and refinement. Besides presenting the language, this paper defines its semantics and provides a description of the interpreter for the language that has been implemented.
Electronic Commerce over the Internet is one of the most rapidly growing areas in todays business. However, considering the most important phase of Electronic Commerce, the payment, it has to be noted that in most currently exploited approaches support for at least one of the participants is limited. From a general point of view, a couple of requirements for correct payment interactions exist, namely different levels of atomicity in the exchange of money and goods of a single customer with different merchants. Furthermore, as fraudulent behavior of participants in Electronic Commerce has to be considered, the ability to legally prove the processing of a payment transaction is required. In this paper, we identify the different requirements participants demand on Electronic Commerce payment from the point of view of execution guarantees and present how payment interactions can be implemented by transactional processes. Finally, we show how the maximum level of execution guarantees can be provided for payment processes in a natural way by applying transactional process management to an Electronic Commerce Payment Coordinator.
The Co-nets approach that we are developing is an object- oriented (OO) specification model based on a formal and complete integration of OO concepts and constructions into an appropriate variant of algebraic Petri nets. Interpreted in rewriting logic, the approach is particularly tailored for specifying and validating advanced information systems as distributed, autonomous yet cooperative components. However, in spirit of most existing conceptual models, the Co-nets approach requires that all system aspects have to be known during its specification and fixed at once; a fact going in contrast to reality where most systems, due to different changes in business and law factors, have to change their behaviour in unexpected way during their long life-span. With the objective to overcome this crucial limitation, we present in this paper first steps towards an appropriate extension of Co-nets approach for naturally dealing with specification evolution. The main ideas are based on, first, distinguishing between a rigid, fixed object behaviour part and a modifiable one. Second, besides usual transitions and places, we introduce the notions of meta-places and meta-transitions for dynamically governing the modifiable behaviour. Third, we propose for meta-transitions two-steps (i.e. meta- and object levels) valuated rewriting rules.
This paper presents a solution to check integrity constraints in database systems supporting nested transactions. Using nested transactions allows to introduce parallelism inside a transaction and to partially recover failing transactions by defining a hierarchy of sub-transactions. If a constraint is violated by some sub-transactions, it is possible to reach the validation of the nested transaction, even if some part of it had to be aborted. In our solution, (i) only constraints that might be violated are checked, (ii) constraints are checked as soon as possible during the execution of the nested transaction and (iii) as few sub-transactions as possible are aborted. We do not interfere with the execution control of nested transactions and users do not have to add any control code in the definition of constraints or of transactions. The main idea of our solution is to attach the checking of a constraint to the smallest common ancestor of the sub-transactions which could violate the constraint.
Electronic Commerce is a rapidly growing area that is gaining more and more importance not only in the interrelation of businesses (business-to-business Electronic Commerce) but also in the everyday consumption of individuals performed via the Internet (business-to-customer Electronic Commerce). Since Electronic Commerce is a very interdisciplinary area, it has a lot of impacts to various communities. The goal of this paper is to identify and to summarize the impact of Electronic Commerce from a database transaction point of view and to highlight open problems in transaction management arising in Electronic Commerce applications by reflecting the discussions of the working group “Transactions and Electronic Commerce” held at the TDD Workshop.
The rule-based update language ULTRA has been designed for the specification of complex database updates in a modular fashion. The logical semantics of update goals is based on update request sets, which correspond to deferred basic updates in the database. The declarative character of the logical semantics leaves much freedom for various evaluation strategies, among them a top-down resolution, which can be mapped naturally onto a system of nested transactions. In this paper, we extend this operational model as follows: Not only the basic operations are performed and committed independently from the top-level transaction, but also complex operations defined by update rules. This leads to an open nested transaction hierarchy, which allows to exploit the semantical properties of complex operations to gain more concurrency. On the other hand, high-level compensation is necessary and meta information must be provided by the programmer. We present the key elements of this combination of logic-based update languages and transaction processing and propose a flexible system architecture.
