Objectoriented Database Management Systems
.. ld be extensible i.e. the user should be able to define his/her own types and treat them in the same way he/she treats the predefined ones. In other words, user types and system types should have the same status although perhaps they are differently supported by the system itself. Persistence is one of the most basic features of a DBMS (at least the most evident one) and hence of an OODBMS. It is the ability of the programmer to have his/her own data survive the execution of a process so that he/she can eventually reuse it in another process.
For an object-oriented system, there is an additional requirement which stems from the extensibility requirement, that any object must be able to become persistent independently of its type. The secondary storage management is one of the most important DBMS features. It should include a set of mechanisms that improve the performance of the system like indexing, clustering, access path selection, data buffering, or caching. The designer of the databases should be able to choose if he/she will activate these mechanisms or not, although for application programmers the use of these mechanisms should be transparent and not require special effort for their maintenance. The database management system should be able to support many users.
That means that they must provide special mechanisms for the concurrency of the accesses of the data, and the arbitration in case of conflicts. Such mechanisms have already been provided by the RDBMSs and hence should also be provided by the OODBMSs. A basic requirement for a database system is that in case of a hardware or software failure, the system should be able to bring itself back to the most recent coherent state of the data. This feature has to do with the concurrency control and the transaction management, but also requires extra mechanisms that have already been explored and studied for the RDBMSs. A DBMS should provide its users with a simple interactive way of making ad-hoc queries and receiving answers.
For this purpose, the OODBMS can provide a special query language as the RDBMSs did, a specially extended programming language, or some graphical tools (browsers, forms, etc.). Whatever they do provide should satisfy the following: it should be high-level so that the queries will be simple and easily understood by humans, it should be efficient, and it should be application independent. In this section I will analyze the optional features that an OODBMS should have. Some of them have to do with the object-oriented nature of the system, and some others with the handling of persistent data. Multiple inheritance allows the creation of a new class from one or more other classes. There is no general agreement if a system must support multiple inheritance or not.
It is true, however, that the systems that support this feature make the application design easier since multiple inheritance is a more powerful tool than single inheritance. On the other hand, many problems arise from the support of multiple inheritance that have to do with conflicts among the attributes and methods inherited by more than one arbitrary class. The degree of type checking performed at compile time should be as great as possible. The optimal situation is where a program that was accepted by the compiler cannot produce any run-time errors. It is desirable for a system to be distributed although that is independent from the fact that it is an object-oriented system.
Concurrency control is one of the mandatory features of a DBMS, but the current systems are intended to be used for handling very long data like images, sound, text, etc. and consequently they should provide special transaction mechanisms in order to allow the efficient handling of such kinds of data. The RDBMSs do not support such handling and therefore the object-oriented technology had to enhance the classical transaction framework with long and nested transactions. Most of the applications evolve and they do no acquire a stable state until a long time after their initial implementation. For this reason it should be possible to do the following: the old data should not be overridden by new ones but should be kept and coexist as older versions of the same object and not as independent objects; and in case of schema changes, the data that corre! spond to previous schemas should not be thrown away but should evolve following the schema evolution. There is a set of features, finally, for which the designers can choose among different implementations that are not equivalent, but they have certain advantages and disadvantages.
There are plenty of programming models (C++, Lisp, Smalltalk, etc.), but none of them should be considered better than the others. The designers choose the programming model of their system according to the kind of applications that the system is going to serve. The choice of the programming style is open as well. The one that better suits the applications should be chosen. The representation system is the set of the types or classes provided by the system as well as the set of constructors that can be applied on these classes. As long as the system provides support for extensibility and composite objects, there is no restriction of which member the representation should contain.
There are systems that support the highest degree of uniformity, which means that everything in the system includ! ing classes, methods, messages, etc. is treated as an object. Uniformity has consequences at the level of the implementation of the system and at the level of the application programming and the user interface as well. Although uniformity is a nice feature and simplifies the implementation of the system, it can sometimes confuse the users since in reality there is no absolute uniformity. The design of the relational database system and the mechanisms that they use have been mathematically founded. Most of them are the result of long research periods that lead to the successful solving of the most important problems that occurred in these systems. The object-oriented database systems, since they are fairly new, do not have a very sound theoretical solution for many of the issues that arise from their implementations.
Here are some of the problems introduced by the new approach: * The object-oriented model contains some concepts whose semantics are still under discussion. There is no standard data model and consequently there is no standard methodology for designing an object-oriented scheme. For the relation systems on the contrary, the ER diagram is totally acceptable. * The query language of the relational systems was base on the mathematical theory of the relational algebra and the relational calculus. There is not something similar for the OODBMS. A lot of effort has been done for the definition of an object-oriented algebra since it is clear that the relational algebra is inadequate for the support of the object-oriented model.
* The traditional indexing and locking techniques used should be extended in order to be used for object-oriented databases. The composite objects cause a lot of trouble and is still an open research issue. * The complexity of the hierarchies of classes created can be so big that the schemas can be handled with difficulty. The object-oriented systems are very much successful in areas where their predecessors failed: * The design of the schema can be done in a very direct way since the object-oriented model is very close to the real world model. On the contrary, the relational design which is based on canonical forms of the relational system is much more awkward.
* The maintenance of the database is much easier due to the schema evolution facilities and the modular design allowed by the object-oriented model. * The identity concept that gives one internal pointer to each object throughout its life protects the consistency of the database and helps modeling similar real world entities. In the relational systems, this identification number was inevitably user provided. * The database is not only used for storing data but also pieces of code (methods) that run on the data. Consequently, a whole application can be stored and executed with the help of the OODBMS that also supports its maintenance.
* The inheritance concept makes code easily reusable. * The expensive join operations of the relational systems have been substituted by the composite object notion, which combined with the clustering mechanism can improve the performance of the composite object retrieval. There are many applications that have been using the relational systems very successfully now for many years and they do not need to change. However, there are a couple of other applications especially in the engineering fields that dont do much with relational systems, mainly from the modeling aspect. For these kinds of applications, the object-oriented approach seems quite appropriate in spite of the problems that still have to be solved. Works Cited Brown, A.W. Object-Oriented Databases: Applications in Software Engineering. McGraw-Hill, 1991.
Burleson, D.K. Practical Application of Object-Oriented Techniques to Relational Databases. Wiley/QED, 1994. Chorafas, D.N. and H.
Steinmann. Object-Oriented Databases. Prentice-Hall, 1993. Delobel, C., C. Lecluse, and P. Richard. Databases: From Relational to Object-Oriented Systems. ITP, 1995.
Gray, P.M.D., K.G. Kulkarni, and N.W. Paton. Object-Oriented Databases: A Semantic Data Model Approach. Prentice-Hall, 1992. Hughes, J.G.
Object-Oriented Databases. Prentice-Hall, 1991. Kemper, A. and G. Moerkotte. Object-Oriented Database Management: Applications in Engineering and Computer Science. Prentice-Hall, 1994. Kim, W.
Introduction to Object-Oriented Databases. MIT Press, 1990. Loomis, M.E.S. Object Databases: The Essentials. Addison-Wesley, 1995. Rao, B.R. Object-Oriented Databases: Technology, Applications, and Products. McGraw-Hill, 1994.