A multi-level architecture for distributed object bases

Abstract

The work described in this article arises from two needs. First, there is still a need for providing more sophisticated database systems than just relational ones. Secondly, there is a growing need for distributed databases. These needs are addressed by fragmenting schemata of a generic object data model and providing an architecture for its implementation. Key features of the architecture are the use of abstract communicating agents to realise database transactions and queries, the use of a remote object call mechanism to enable remote agents to communicate with one another, and the use of multi-level transactions. Linguistic reflection is used to map database schemata to the level of the agents. Transparency for the users is achieved by using dialogue objects, which are extended views on the database.

Introduction

The amount of data that is collected and stored in databases is steadily growing. In many cases the structure of these data is not adequately reflected in the database schema and query languages. E.g. many databases containing important biological data are organised more or less as flat files. In addition, the centralisation of data in a big central database becomes more and more a handicap for efficient data processing. As data arises at various locations and will be used at various other locations as well, the need for data distribution increases.

As to the structure of the data, the research in the last decade has investigated complex values (i.e. data constructed by various type constructors) and references/links between data – which in fact lead to infinite, yet finitely representable structures. The object oriented data model (OODM) from [1] allows these different aspects to be combined. Starting from an arbitrary underlying type system a schema is defined as a set of classes, each of which combines complex values and references. Thus, the theory of that data model can be tailored according to the underlying type system. This has been exploited in [2] to define a generic query algebra.

Thus, in order to satisfy the identified needs it is a natural idea to develop a distributed database system based on this OODM. The first problem that has to be addressed is the distribution of the data. The fragmentation and allocation of OODM schemata have recently been addressed in [3], [4], [5]. The result of fragmentation and allocation will be still an OODM schema, but each class will be allocated to exactly one node – or in the case of replication several nodes – of a network. As a consequence the global objects corresponding to the original schema would be represented by several local objects for the fragmented schema.

However, the structure of local objects is still complex, whereas efficient storage and retrieval would require to provide just records stored on pages. This implies to further decompose objects as we move closer to the physical storage, so that we obtain multiple levels of objects.

The existence of multiple levels for objects suggests to exploit the concept of multi-level transactions [6], [7], [8], [9] for the database functionality. Multi-level transaction schedulers exploit the fact that many low-level conflicts become irrelevant, if higher-level operation semantics are taken into account. The introduced system uses the hybrid multi-level concurrency control protocol FoPL [9], [10] as well as the more familiar two-phase locking protocol [8], [10]. Both are combined with a multi-level recovery system [9], [11] based on the ideas from the ARIES system [12].

The multiple object levels are also reflected in the operational system, which exploits the ideas of stack-based abstract machines [13], [14] to implement database functionality, and in particular, to integrate the processing of queries and transactions. However, these machines have to be extended in a way that they can communicate with each other including communication via remote object calls, run in parallel, are coupled with the transaction manager and the persistent object store, and reflect the operations on higher levels of the multi-level system.

Two more problems have to be addressed. The first one concerns the transformation of high-level queries and operations to the level of these stack-based machines. For this we exploit linguistic reflection [15], [16]. We provide a macro language, in which the high-level constructs in transactions such as generic update operations and the high-level algebra constructs for querying can be formulated. In [17] it has been shown how linguistic reflection can be used to expand such macros for the case of query algebra constructs. In [18] linguistic reflection has been applied to expand macros for generic update operations.

The second problem concerns transparency at the user interface. We follow the idea to provide dialogue interfaces based on dialogue objects, which are defined by extended views [19]. These dialogue objects can be created anywhere in the network. Starting an operation associated with such a dialogue object would create a master agent at the user’s node and start executing a top-level transaction.

Section 2 provides a brief overview of discussions and research activities, developments on the subject of object-oriented database systems, and our intended contribution. In Section 3 we give a more detailed overview of the architecture of our proposed system. Section 4 then briefly describes the data model, the user interface integration, fragmentation and allocation, and linguistic reflection. In Section 5 we describe more details of the operational architecture, which is comprised of components that execute database requests efficiently, support distribution, parallelism, concurrency, persistence, etc. In Section 6.1 we briefly discuss how data is cached in main memory. Section 7 briefly addresses the realisation of a corresponding prototype system. Finally, Section 8 concludes our work.