Object-oriented Database Systems Research Articles

Signature caching in parallel object database systems

In many application areas, the access pattern is navigational and a large fraction of the accesses are perfect match accesses/queries on one or more words in text strings in the objects. One example of such an application area is XML data stored in object database systems. Such systems will frequently store large amounts of data, and in order to provide the necessary computing power and data bandwidth, a parallel system based on a shared-nothing architecture can be necessary. In this paper, we describe how the signature cache approach can significantly reduce the average object access cost in parallel object database systems.

The Goql Graphical Query Language

The authors present a graphical query language, GOQL (Graphical Object Query Language), for object-oriented data base systems, in general, and the object model of ODMG 2.0, in particular. A detailed literature survey of related work is given, and an analysis methodology that allows the evaluation of such languages is proposed. Moreover, the user's view of GOQL is presented. The user's view provides a graphical schema that does not contain any of the perplexing details of an object-oriented database schema; it also provides a graphical interface that supports ad hoc queries for object-oriented database applications. Because there is a direct correspondence between the features of GOQL and OQL (GOQL supports all the features of OQL), the language can be used as an alternative graphical interface to OQL. Thus, GOQL allows users to express queries graphically ranging from simplistic to complicated ones. Among the features provided/supported by the language are: a 2D colour interface, methods, predicates, Boolean and set operators, arithmetic expressions, existential/universal quantifiers, aggregate functions, group by and sort operators, functions, and subqueries. In this article, we illustrate through examples both the user's view and the query mechanism of GOQL. This work represents the completion of work that was partially presented in earlier articles.

The Soprano Extensible Object Storage System

An efficient object manager, a middle layer on top of a storage system, is essential to ensure acceptable performance of object-oriented database systems, since a traditional record-based storage system is too simple to provide object abstraction. In addition, an object storage system–object managers in combination with storage systems - should be extensible to meet the various requirements of emerging applications. In this research, we design and implement an extensible object storage system, called Soprano, in an object-oriented fashion which has shown great potential in extensibility and code reusability. Soprano provides a uniform object abstraction and gives us the convenience of persistent programming through many useful persistent classes. Also, Soprano supports efficient object management and pointer swizzling for fast object access. This paper investigates several aspects of the design and implementation of the extensible object storage system. Our experience shows the feasibility of using an object-oriented design and implementation in building an object storage system that should have both extensibility and high performance.

Issues in Transaction-Time Temporal Object Database Systems

Object database systems (ODBs) are an attractive alternative to relational database systems, especially in application areas where the modeling power or performance of relational database systems is insufficient. These applications typically maintain large amounts of data. Frequently, some of the data is temporal data. For the temporal data, the whole history of the individual objects is kept, and data is never deleted. The area of temporal ODBs is still immature, and there are many design issues that need to be solved in order to be able to achieve the desired performance. In this paper, we discuss some temporal ODB research issues and possible solutions related to object storage, object management, main memory buffering, and language bindings.

ROVER: flexible yet consistent evolution of relationships

Relationships have been repeatedly identified as an important object-oriented modeling construct. Most emerging modeling standards such as the object database management group (ODMG) object model and UML have some support for relationships. However object-oriented database (OODB) systems have largely ignored the existence of relationships during schema evolution. We are the first to propose comprehensive support for relationship evolution. A complete schema evolution facility for any OODB system must provide primitives to manipulate all object model constructs, and maintenance strategies for the structural and referential integrity of the database under such evolution. We propose a set of basic evolution primitives for relationships as well as a compound set of changes that can be applied to the same. However, given the myriad of possible change semantics a user may desire in the future, any pre-defined set is not sufficient. Rather we present a flexible schema evolution framework that allows the user to define new relationship transformations as well as to extend existing ones. Addressing the second problem, namely of updating schema evolution primitives to conform to the new set of invariants, can be a very expensive re-engineering effort. In this paper we present an approach that de-couples the constraints from the schema evolution code, thereby enabling their update without any re-coding effort. We also present an approach that can be used to verify the correctness of these complex evolution operations using the de-coupled constraints.

Probabilistic object bases

Although there are many applications where an object-oriented data model is a good way of representing and querying data, current object database systems are unable to handle objects whose attributes are uncertain. In this article, we extend previous work by Kornatzky and Shimony to develop an algebra to handle object bases with uncertainty. We propose concepts of consistency for such object bases, together with an NP-completeness result, and classes of probabilistic object bases for which consistency is polynomially checkable. In addition, as certain operations involve conjunctions and disjunctions of events, and as the probability of conjunctive and disjunctive events depends both on the probabilities of the primitive events involved as well as on what is known (if anything) about the relationship between the events, we show how all our algebraic operations may be performed under arbitrary probabilistic conjunction and disjunction strategies. We also develop a host of equivalence results in our algebra, which may be used as rewrite rules for query optimization. Last but not least, we have developed a prototype probabilistic object base server on top of ObjectStore. We describe experiments to assess the efficiency of different possible rewrite rules.

Fine-granularity signature caching in object database systems

In this paper, we present the SigCache approach. In contrast to traditional signature files where signatures are stored in separate files, signatures are in our approach stored together with their objects. In addition, the most frequently accessed signatures are stored in a main memory signature cache (SigCache). When using the signatures stored in the SigCache as a filter during perfect match queries, the number of objects that actually have to be retrieved during perfect match queries can be reduced. The increase in update cost is insignificant, because the signatures are much smaller than the objects.

A cost-based buffer replacement algorithm for object-oriented database systems

Abstract Many object-oriented database systems manage object buffers to provide fast access to objects. Traditional buffer replacement algorithms based on fixed-length pages simply assume that the cost incurred by operating a buffer is proportional to the number of buffer faults. However, this assumption no longer holds in an object buffer where objects are of variable-lengths and the cost of replacing an object varies for each object. In this paper, we propose a cost-based replacement algorithm for object buffers. The proposed algorithm replaces the objects that have minimum costs per unit time and unit space. The cost model extends the previous page-based one to include the replacement costs and the sizes of objects. The performance tests show that the proposed algorithm is almost always superior to the LRU-2 algorithm and, when significant replacement cost is involved, is more than twice as fast.

Building deductive object-oriented database systems in the ODMG era

Deductive object-oriented database systems (DOODs) have been a subject of intensive research for the last 13 years, with results embodied in several research prototypes and one commercial system produced so far [1]. However, despite the considerable number of systems available, there has been surprisingly little work on organising and analysing the several system architectures and query processing strategies that have been employed in the construction of DOODs. Furthermore, with the consolidation of the ODMG specification as a standard for object databases, it is important to assess which architectural approach is better suited for building DOODs considering the ODMG framework. This paper categorises several representative DOOD systems based on their architecture and query processing approach, and provides an analysis of the issues involved in building DOOD systems compliant with the ODMG standard.

A strategy for adding fuzzy types to an object-oriented database system

Fuzzy types have been developed as a new way of managing fuzzy structures. With types of this kind, properties are ordered on different levels of precision or amplitude, according to their relationship with the concept represented by the type. In order to implement this new tool, two different strategies can be followed. On the one hand, a new system incorporating fuzzy types as an intrinsic capability can be developed. On the other hand, a new layer that implements fuzzy types can be added to an existing object-oriented database system (OODB). This paper shows how the typical classes of an OODB can be used to represent a fuzzy type and how the mechanisms of instantiation and inheritance can be modeled using this kind of new type on an OODB. © 2001 John Wiley & Sons, Inc.

OgDesk: an orthogonal graphical interface for object-oriented database systems that supports schema management, browsing and querying

This paper reports on a graphical interface, OgDesk, for object-oriented database systems (OODBs). It orthogonally supports the activities of•Browsing types and instances•Creating and maintaining instances•Creating, using and programming with graphical representations of single type queries•Creation, maintenance and evolution of the schema.

A Syntax-based Gateway between SQL3 and ODMG Languages

Object-oriented technology is an emerging information technology. Object-oriented database technology represents a breakthrough from the dominant relational model. Lacking the similar popularity and acceptance of SQL, object-oriented database management systems, however, are going through a difficult period of standardization. Due the complexity of object-oriented technology and the sophistication of distributed (Internet) computing, object database systems need an efficient and effective way to tackle the issue of heterogeneity and incompatibility. In this paper, we propose a syntax-based gateway model to bridge two key object standards of SQL3 and ODMU. The gateway model is methodological and systematic. The basic belief is that a real representation of the real world has to be discovered to resolve the middleware issue. In this method, we employ a set of general and generic components and constructs that compose a real world object system. We use the set to compare and contrast the composition of SQL3 and ODMG. We devise a limited set of conversion rules to convert the compositions one at a time. A transformation model is built. This approach is traceable and reversible because it is based on analysis design constructs. We have implemented the gateway model. The prototype is composed of an analyzing module, lexical scanner, and grammar parser.

Regular database update logics

We study regular first-order update logic (FUL), which is a variant of regular dynamic logic in which updates to function symbols as well as to predicate symbols are possible. We first study FUL without making assumptions about atomic updates. Second, we look at relational algebra update logic ( RAUL), which can be viewed as an extension of relational algebra with assignment. RAUL is an instantiation of FUL. Third, we study dynamic database logic ( DDL), which is another version of FUL, in which the atomic updates can be “bulk updates” of predicates and updates of updateable functions. In all three cases, we define syntax, declarative semantics, axiomatizations, and operational semantics of the logic. All axiom systems are shown to be sound. Assuming the domain closure and unique naming assumptions, we also give a proof sketch of completeness of the axiomatization of DDL. The operational semantics presented in the paper are shown to be equivalent to the declarative semantics for certain classes of databases. We give examples of correctness proofs in RAUL and in DDL. Finally, we compare our approach to that of others and show how DDL can be used as a logic in which to specify and reason about updates to an object-oriented database system.

Road accident investigation using an object-oriented database

The continuation of the downward trend in the number of injuries arising from road accidents in Britain and the effectiveness of casualty reduction targets are both dependent upon the availability of improved high-quality information. This paper describes the development of, and issues surrounding, an experimental road accident database within a geographical information system (GIS). It highlights ways in which the quality and completeness of road accident data may be improved by providing a separate definition of the road network and considers the benefits of using an object-oriented database system.

Advanced database concepts for undergraduates

This paper describes the development of a second database course for undergraduates, preparing students for the advanced database concepts they will experience in industry. Assuming an introductory course on relational database systems as a prerequisite, the topics addressed in the course include object-oriented data modeling, object-oriented database systems, object-relational database systems, Web access to databases, and professionalism and ethics. We present our experience with teaching the course, elaborating on the topics and assignments. We also present feedback from students and industry partners as well as our own assessment of future course refinements.

Road accident investigation using an object-oriented database

The continuation of the downward trend in the number of injuries arising from road accidents in Britain and the effectiveness of casualty reduction targets are both dependent upon the availability of improved high-quality information. This paper describes the development of, and issues surrounding, an experimental road accident database within a geographical information system (GIS). It highlights ways in which the quality and completeness of road accident data may be improved by providing a separate definition of the road network and considers the benefits of using an object-oriented database system.

A multi-granularity locking-based concurrency control in object-oriented database systems

In this paper, a concurrency control scheme to increase concurrency among methods in object-oriented database systems (OODBs) is presented. The author is concerned with all types of access to an object: instance access and class definition access. For instance access, the proposed work has the following characteristics. First, construction of commutativity relation among methods can be automated. Second, it provides more concurrency by taking attributes as locking granularity. Third, deadlocks due to lock escalation can be reduced. Finally, concurrency is increased further with the use of run-time information. For class definition access, the proposed work allows class definition access methods to run concurrently by taking fine granularity. The proposed work also allows more parallelism between class definition access methods and instance access methods. For the performance evaluation of the proposed scheme, a simulation model is constructed. Using this model, the proposed technique is then compared with the two existing techniques. The performance studies show that the proposed scheme is superior to existing works.

Updates and object-generating views in ODBS

In object-oriented database systems, a view mechanism can extend the object paradigm by adapting object structure and object behavior to the needs of the different applications or users. In this paper we consider views with object-generating semantics which is an important construct in database environment and mediator systems (Y. Papakonstantinou, S. Abiteboul, H. Garcia-Molina, Object Fusion in Mediator Systems, in: Proceedings of the International Conference on Very Large DataBases, New York, July 1998). We reexamine the problem of updating views according to the aspects of object-orientation, namely: object identity, inheritance and aggregation path. Furthermore, we propose a taxonomy of virtual classes in order to define the update semantics with respect to the virtual class semantics. We present also a cost model for our update algorithms to quantify the impact of our materialization method upon updates propagation times.

Fuzzy objects for geographical information systems

Modeling, storing and retrieving geographical information has become an important part of our information society. Geographical information is typically specified in terms of collections of entities and phenomena that are structured aggregations of spatial entities. GIS features tend to form natural class hierarchies. Another characteristic of geographical information is that often it may be inexact or vague. With respect to these characteristics, the confluence of the two technologies fuzzy set theory and object-oriented databases could provide a powerful tool for knowledge representation underlying geographical information systems. The fuzzy object data model is currently being developed and prototype implementations have been undertaken using an integrative approach with existing software including an expert system shell and a commercial object-oriented database system. In this paper, the benefits of a fuzzy object data model for geographical information systems are examined, an overview of the model is presented, and the current prototype implementations are described.

The evaluation of access costs in object databases

Unfortunately, there is at present nothing to assist the system architect at design-time to determine whether a proposed architecture based on an object-oriented database system will perform as required. The problem is complex, the choice of suitable modelling approach difficult, and a construction of a model is often abstruse. In this paper we concentrate on a major model component: that describing the access of objects in a centralised database. We present the background for the research (modern corporate IS architectures), the choices we have made, the prototype design, and the mathematical model of the cost of object database access. We conclude the paper by describing a validation of the model and how it can be generalised. The paper has a number of objectives: first, to dispel the myth that performance modelling of object-oriented systems is an immensely difficult task; second, to show that techniques which have been in existence for some time for modelling are applicable, with some modification, to aspects of object-oriented database performance prediction; and, third, to detail a specific case study of access cost modelling which provides enough information to be replicated by other workers across a number of object-oriented database products.