The use of hierarchy is an important component of object-oriented design. Hierarchy allows the use of type families, in which higher level supertypes capture the behavior that all of their subtypes have in common. For this methodology to be effective, it is necessary to have a clear understanding of how subtypes and supertypes are related. This paper takes the position that the relationship should ensure that any property proved about supertype objects also holds for its subtype objects. It presents two ways of defining the subtype relation, each of which meets this criterion, and each of which is easy for programmers to use. The subtype relation is based on the specifications of the sub- and supertypes; the paper presents a way of specifying types that makes it convenient to define the subtype relation. The paper also discusses the ramifications of this notion of subtyping on the design of type families.

. The traditional focus of relational query optimization schemes has been on the choice of join methods and join orders. Restrictions have typically been handled in query optimizers by "predicate pushdown" rules, which apply restrictions in some random order before as many joins as possible. These rules work under the assumption that restriction is essentially a zero-time operation. However, today's extensible and object-oriented database systems allow users to define time-consuming functions, which may be used in a query's restriction and join predicates. Furthermore, SQL has long supported subquery predicates, which may be arbitrarily time-consuming to check. Thus restrictions should not be considered zero-time operations, and the model of query optimization must be enhanced. In this paper we develop a theory for moving expensive predicates in a query plan so that the total cost of the plan --- including the costs of both joins and restrictions --- is minimal. We present an algorithm to implement the theory, as well as results of our implementation in POSTGRES. Our experience with the newly enhanced POSTGRES query optimizer demonstrates that correctly optimizing queries with expensive predicates often produces plans that are orders of magnitude faster than plans generated by a traditional query optimizer. The additional complexity of considering expensive predicates during optimization is found to be manageably small. 1

We define an algebra which synthesizes relational query concepts with object-oriented databases. The algebra fully supports abstract data types and object identity while providing associative access to objects, including a unique join capability. The operations take an abstract view of objects and access typed collections of objects through the public interface defined for the type. The algebra supports access to relationships implied by the structure of the objects, as well as the definition and creation of new relationships between objects. The structure of the algebra and the abstract access to objects offer opportunities for query optimization. 1 Introduction Object-oriented databases are emerging in response to a requirement for more complete modelling of complex data in modern design and office environments. Such databases attempt to combine the modelling power of object-based programming models with traditional database concepts such as persistence, data sharing, cons...

data types can also define equality operations. Such operations are typespecific and will not be considered in this paper. Objects can be represented graphically, where nodes are objects or atomic values, arcs connect collection type objects to all objects that are members of the collection, and arcs connect non-collection type objects to the values of all properties of that object (similarly to [11] for example). Nodes representing atomic values are leaves and are labelled with the atomic value. Nodes representing non-atomic objects are labelled with an (artificial) object identifier as well as the object type. Types can be labelled symbolically, using ? for set types, !? for tuple types, and ffl for other abstract data types. In Figure 1 three set objects are represented graphically. Note that graphs b and c represent 3-equal set objects: C 2 and C 1 are 1-equal, making t 3 and t 5 2-equal (t 1 and t 4 are 1-equal, therefore 2-equal), thus S 2 and S 3 are 3-equal. Object S1 (graph a...

In this paper, different approaches are classified and evaluated for optimizing the access to main-memory resident persistent objects---techniques which are commonly referred to as "pointer swizzling ". To speed up the access along inter-object references, the persistent pointers in the form of unique object identifiers (OIDs) are transformed (swizzled) into main-memory pointers (addresses). Pointer swizzling techniques can be directed into two classes: (1) strategies that allow replacement of swizzled objects from the buffer before the end of an application program and (2) those that outrule the displacement of swizzled objects. Whereas the latter class of pointer swizzling methods has received much attention in recent literature, the first class---i.e., techniques that take "precautions" for the replacement of swizzled objects---has not yet been thoroughly investigated. Four different pointer swizzling techniques allowing object replacement were investigated and contrasted with the p...

In this paper, three techniques to implement logical OIDs are thoroughly evaluated: hashing, B-trees and a technique called direct mapping. Among these three techniques, direct mapping is the most robust; it induces at most one page fault to map an OID, and it scales very well to large, rapidly growing databases. Furthermore, the clustering of handles that are used to map logical OIDs is studied. In particular, the performance of B-trees and direct mapping can improve significantly if the handles of objects that are frequently accessed by the same methods are clustered. For direct mapping, two placement policies are compared: linear and matrix clustering. 1 Introduction The full support of object identity is one of the most important features of object-oriented database systems [KM94]. To improve referential integrity, an object base system allocates an object identifier (OID) to every object at the time the object is created. The OID is used to identify the object uniquely and to im...

In a distributed storage system, client caches managed on the basis of small granularity objects can provide better memory utilization then page-based caches. However, object servers, unlike page servers, must perform additional disk reads. These installation reads are required to install modified objects onto their corresponding disk pages. The opportunistic log is a new technique that significantly reduces the cost of installation reads. It defers the installation reads, removing them from the modification commit path, and manages a large pool of pending installation reads that can be scheduled efficiently. Using

Object-oriented databases store many small objects on disks. Disks perform poorly when reading and writing individual small objects. This thesis presents a new storage management architecture that substantially improves disk performance of a distributed object-oriented database system. The storage architecture is built around a large modified object buffer (MOB) that is stored in primary memory. The MOB provides volatile storage for modified objects. Modified objects are placed in the MOB instead of being immediately written out to disk. Modifications are written to disk lazily as the MOB fills up and space is required for new modifications. The MOB improves performance because even if an object is modified many times in a short period of time, the object has to be written out to disk only once. Furthermore, by the time an object modification has to be flushed from the MOB, many modifications to other objects on the same page may have accumulated. All of these modifications can be writ...

In this thesis we address the problem of providing efficient processing of queries in the extensible environment induced by object-oriented databases. We define a framework for query processing in an object-oriented database and develop designs for major components of this framework. The framework encompasses an object-oriented data model, an algebra to query over that model, transformation rules for the algebra, an internal representation for queries expressed in the algebra, a cost model for analyzing query expressions, and an architecture for an extensible query optimizer. The major contributions of this thesis are an algebra and transformation rules, a representation, and an architecture for extensible query optimization. We show how these components fit into the framework and interact with each other. The EQUAL query algebra presented in this thesis is the first query algebra for object-oriented database systems to be completely consistent with data abstraction, and one of the few...

Although object-oriented database systems o er more powerful modeling capability than relational database systems, their performance su ers from the increased complexity in the data model. Thus, e cient index mechanisms must be used to improve the performance. In this paper, two new signature methods for indexing objectoriented databases and the associated operations are described. The cost models for the analysis of storage overhead and performance of the methods are presented. 1