ROVER: flexible yet consistent evolution of relationships
Introduction
Object-oriented database (OODB) systems today are popular with communities that model complex data types, such as computer-aided design (CAD), multimedia applications and e-commerce applications [39]. The very nature of these applications has also brought forth the need for the OODB systems to provide mechanisms for (1) modeling associations between types and (2) dynamically changing not only the data but also the structure of the types that contain them [45]. Research and industry alike have rushed forth to fulfill these requirements but have approached them as two independent problems with independent solutions. Relationship modeling has been a much-studied topic such as in composite objects [27] or in aggregation relationships [7], [13] and has been adopted to some degree in commercial OODB systems [35], [36]. While most OODB systems to date provide some basic evolution support [4], [35], [48], the OODB community at large does not treat the relationship construct as a first-class entity. Thus, while there is some relationship support at the data level, evolution support for relationships has not been investigated. Our work is the first to bridge this gap and to provide a complete framework for the support of schema evolution for relationships.
A complete schema evolution facility for any OODB system must provide the ability to manipulate and change any object model construct. To achieve this goal a new set of schema evolution primitives to evolve the new construct(s) are required. The OODB system must also maintain the structural and referential integrity of the database. That is, the existing schema evolution primitives must be changed to assure that they now obey the new constraints of the new object model augmented with the relationship construct. For the relationship construct [13] we now propose a set of schema evolution primitives to handle their addition and deletion. One example of such a primitive is form-relationship that creates a bi-directional relationship between two classes that already have two independent uni-directional relationships.
Evolution primitives maintain the consistency of an OODB system by preserving the invariants of the object model at all times. However, an update to the object model changes the set of invariants. Hence, the existing evolution primitives must be updated to conform to the invariants of the new object model. Consider, for example, the existing evolution primitive delete-class. Today, while most OODB systems provide support for relationships by modeling them as reference attributes, the evolution primitives such as delete-class treat them as literal attributes. And while at the object level most OODB systems perform referential integrity checks to ensure referential consistency, at the schema level, referential relationships are largely mistreated during schema evolution, resulting in structurally inconsistent schemas. And while most systems may be able to trap and deal with the referential problems, the schema inconsistencies are often ignored.
However, updating the schema evolution primitives to now conform to the new set of invariants is a huge re-engineering effort. To diminish the cost of updating an existing schema evolution facility while still providing a consistency-preserving schema evolution facility, we propose evolution wrappers based on the concept of software contracts [32] to maintain existing schema evolution primitives in the light of a changing object model. These contracts, declarative in nature, are easy to update and can be changed without the overhead of re-coding.
For relationships, a complex construct with numerous special properties such as cardinality, uni- vs bi-directional, etc., a pre-defined primitive set of operations is not sufficient. Many different primitives may be combined to compose more complex transformations. Moreover, this must all be executed atomically like any pre-defined system-provided primitive. We provide a framework that offers such composite evolution operations while maintaining the integrity and the atomicity of the operations themselves.
A big drawback of the compound primitives is their lack of flexibility. A user, such as a DBA administrator, may wish to create a bi-directional relationship between two completely disjoint classes. Two options for the user are to (1) have the system provide a schema evolution primitive to handle this scenario or (2) write an ad hoc program to accomplish the same. From a system's perspective to a priori assess the needs of the users and to plan for it in a hard-coded fashion is a hard if not an impossible problem. On the other hand, ad hoc programs by the users do not have any guarantee of consistency or atomicity. Thus it is necessary to offer extensibility in our framework that would allow not just the system but also the users to express desired transformations while still providing the guarantee of database integrity as well as the atomicity of the transformations. The solution we present in this paper based on SERF [17] provides an extensible and flexible schema evolution framework for supporting complex relationship evolution.
However, atomicity has a price and while a roll-back-based support for consistency might be adequate for some types of application programs, it is a very expensive management strategy for schema evolution programs. Consider a large schema evolution program which may take over 24 hours [22]. A roll-back due to the detection of an erroneous condition in the 23rd hour is not an attractive or a viable option. It would be much preferable to have a guarantee of success before executing the evolution program. An alternative approach would thus be to allow for verification of schema evolution programs prior to their execution. We present here this alternative approach, a theorem prover to verify the correctness of an operation prior to its execution.
Contributions. In this paper we present a complete solution framework, ROVER, for the evolution of relationships which provides for consistent evolution of relationships while supporting extensibility for user-defined evolution operations. In [16], we made the following contributions:
- •
We identify the problem that current OODB systems while offering relationship support in their object models do not handle evolution of such relationships. We characterize the consistency problems that arise from the use of the existing evolution primitives in these systems;
- •
We propose a minimal set of new evolution primitives needed for supporting the evolution of both uni-directional and bi-directional relationships;
- •
We propose a set of compound evolution primitives for relationships;
- •
We generalize our approach such that users as opposed to the system can now extend the set of schema evolution operations provided by the OODB with their own complex schema evolution operations for relationships; and
- •
We present ROVER Wrappers to reduce the re-engineering costs that would otherwise be incurred in updating the old schema evolution primitives to conform to the new set of invariants.
In this paper, we further extend this work and show, now, how the contracts can indeed be utilized to verify the correctness of a ROVER Wrapper. We thus present here an approach for verification of a ROVER Wrapper via a theorem prover.
Section snippets
Background
In this section, we briefly introduce relationship constructs as defined by the object database management group (ODMG), while full details can be found in [13]. Paralleling the concept of foreign keys in relational databases, object models almost always have support for the association between two classes. Most models support the notion of a reference attribute which defines a one-way association between two classes. The ODMG object model also defines the notion of a bi-directional association
Minimal primitives for relationship evolution
In this section we present a set of evolution primitives needed for the evolving uni-directional (unary) and bi-directional (binary) relationships. The primitives presented here are minimal in that they cannot be decomposed into any other evolution primitives and essential in that they are all required for the evolution of relationships [21]. They can be composed together with other evolution primitives to form more complex transformations, as we will discuss in Section 5.
Compound evolution operations for relationships
While providing some basic capability to evolve relationships these evolution primitives alone are not sufficient to manipulate all the properties of a relationship. For instance, using only the primitives in Section 3 users are unable to change the cardinality of the relationship, i.e., change from a collection to an application type or vice versa. This change could however be accomplished by a combination of other existing schema evolution primitives. Similar to Bréche [10] and Lerner [29],
Flexible evolution of relationships
One of the biggest drawbacks of the compound evolution primitives presented in Section 4 is their pre-determined semantics for the compound changes. Consider for example the rather simple semantics for a compound change, change-cardinality-m1 shown in Fig. 5. We arbitrarily use the most commonly occurring object value as the single-value representative. However, other conversions at the object level such as taking the first, last, or median value of the set values are possible. By hard-coding
Contract-based solution for consistent relationship evolution
Conventionally, schema evolution primitives contain hard-code constraints that parallel the invariants of the object model. These constraints must be satisfied in order to guarantee the consistency of the system. Changes in the object model result in changes to the invariants which may in turn be reflected as an update to schema evolution operations [18]. This is an expensive process requiring the re-engineering of the affected software. Our approach ROVER instead focuses on de-coupling the
Putting contracts to use
ROVER Wrappers provide faster system upgrade to the OODB system when the underlying object model is updated for example with relationships. Namely, we would simply now add additional declarative constraints and behavior to existing schema evolution primitive templates rather than update the system code. With the contracts in place, we can deploy different approaches to verify the correct execution of a ROVER Wrapper. Perhaps, the most straightforward approach is that of checking the
Relationships
Semantic modeling research has looked into the modeling of relationships and the different semantics that can be applied for these relationships [9]. In object databases, Kim et al. [26] have examined the part–whole relationship (composite objects). Bertino and Guerrini [7] have presented a formal composite object model that now supports referential integrity constraints for the ODMG object model. None of them have studied the issue of schema evolution on such object models with relationships.
Schema evolution
Conclusion
In this work, we present the first solution for the evolution of relationships. We provide a flexible mechanism to handle the evolution of relationships. We incorporate the notion of contracts for ROVER Wrappers as an alternative to hard-coding the constraints into the schema evolution primitive and thus help to offset the re-engineering cost. We provide implementation details on ROVER in [18]. The core SERF system for flexible transformation was demonstrated at SIGMOD 2000 [42]. Our approach
Acknowledgements
This work was supported in part by the NSF NYI grants #IIS-97-29878, #IIS-97-96264 and #IIS-99-88776. We would also like to thank our industrial sponsors, in particular, IBM for the IBM partnership award and Excelon Inc. for software contribution.
Kajal T. Claypool is an Assistant Professor at University of Massachussetts, Lowell. She received her BE degree in Computer Engineering from Manipal Institute of Technology, India. She has done post-graduate work at the University of Minnesota and has her Ph.D in Computer Science from Worcester Polytechnic Institute, Worcester, Massachussetts. Her research focuses on managing change in and across database systems. Kajal Claypool received a GE Fellowship in 1999.
References (49)
- et al.
Foundations of Databases
(1995) - et al.
Combining language and database advances in an object-oriented development environment
- et al.
Object-oriented database systems: in transition
- et al.
Semantics and implementation of schema evolution in object-oriented databases
A view mechanism for schema evolution
A view mechanism for object-oriented databases
- et al.
Extending the ODMG object model with composite objects
- et al.
A brief introduction to formal methods
Object-Oriented Analysis and Design
(1994)Advanced primitives for changing schemas of object databases
The GemStone data management system
A generalized constraint and exception handler for object-oriented CAD-DBMS
The Object Database Standard: ODMG 2.0
ROVER: a framework for the evolution of relationships
SERF: schema evolution through an extensible, re-usable and flexible framework
The design of an integrity consistency checker (ICC) for an object-oriented database system
Fundamentals of Database Systems
Schema and database evolution in the O2 object database system
Implementing lazy database updates for an object database system
A development model for data translation
Introduction to HOL: A Theorem Proving Environment for Higher Order Logic
Cited by (4)
Evolving the implementation of ISA relationships in EER schemas
2006, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)Elementary translations: The seesaws for achieving traceability between database schemata
2004, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)TVL_SE - Temporal and versioning language for schema evolution in object-oriented databases
2003, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)Primitive operations for schema evolution in ODMG databases
2003, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Kajal T. Claypool is an Assistant Professor at University of Massachussetts, Lowell. She received her BE degree in Computer Engineering from Manipal Institute of Technology, India. She has done post-graduate work at the University of Minnesota and has her Ph.D in Computer Science from Worcester Polytechnic Institute, Worcester, Massachussetts. Her research focuses on managing change in and across database systems. Kajal Claypool received a GE Fellowship in 1999.
Elke A. Rundensteiner is currently an Associate Professor of the Department of Computer Science at the Worcester Polytechnic Institute, after having been a faculty member at the University of Michigan, Ann Arbor. She has received a B.S. degree (Vordiplom) from the J.W. Goethe University, Frankfurt, West Germany, an M.S. degree from Florida State University, and a Ph.D. degree from the University of California, Irvine, all in Computer Science. Dr. Rundensteiner has been active in the database research community for over 15 years, and her current research interests include database evolution and migration, web data management, data warehousing for distributed systems, information integration, exploration and visualization, and advanced database applications. She has more than 100 publications in these and related areas. Her research has been funded by government agencies including NSF, ARPA, NASA, CRA and DOT, and by industry including IBM, Verizon Labs, GTE, AT&T, Intel, Informix and GE. Dr. Rundensteiner has received numerous honors, including Fulbright, NSF Young Investigator, and IBM Partnership Award.
Dr. George T. Heineman is an Assistant Professor of Computer Science at WPI. His research interests are in Component-Based Systems, Software Engineering, and Object-Oriented Design. Professor Heineman received a distinguished National Science Foundation CAREER award in 1997 to pursue his research on designing adaptable software components. He has recently published an edited book with Addison-Wesley entitled “Component-Based Software Engineering: Putting the Pieces Together”.