Optimizing and Parallelizing Loops in Object-Oriented Database Programming Languages

this paper. The purpose of this section is not to exhaustively enumerate the types of queries that can be optimized, but rather to demonstrate that the ideas in this thesis can be implemented and can significantly improve performance

Optimizing Loops in Database Programming Languages

Database programming languages like O 2 , E, and O++ include the ability to iterate through a set. Nested iterators can be used to express joins. We describe compile-time optimizations of such programming constructs that are similar to relational transformations like join reordering. Ensuring that the program's semantics are preserved during transformation requires paying careful attention to the flow of values through the program. This paper presents conditions under which such transformations can be applied and analyzes the I/O performance of several different classes of program fragments before and after applying transformations. The analysis shows that the transformations can significantly reduce the number of I/Os performed, even when both the initial and transformed programs use the same join method. 1 Introduction Many researchers believe that an object-oriented database system (OODBS) must be computationally complete--- that programmers and database administrators must have a..

Multi-Granularity Locks in an Object-Oriented Database

Multi-granularity locking is widely accepted today as an important performance booster for concurrency control in relational databases. In this paper, we address the issues that arise in applying the same idea to an objectoriented database. First, with encapsulated implementations providing interfaces to objects, it is both possible and beneficial to define conflict relationships between pairs of operations allowed on objects of a particular class. This, in turn, translates into a need for a rich and extensible set of lock types that can be used at different granularities (e.g. object, file, database). Second, objects often participate in multiple collections. Thus, there may be no simple hierarchy of locking granules but rather an arbitrary graph with inclusion and intersection relationships. Moreover, updates to the database could result in modifications to this graph. Thus, this graph becomes a point of potential high contention and care is required to ensure that transactions lock ..

Pointer-Based Join Techniques for Object-Oriented Databases

In this paper, we describe and analyze four parallel pointer-based joins for set-valued attributes. These joins will be common in next-generation object-oriented database systems, so efficiently supporting them is crucial to the performance of such systems. Pointer-based join algorithms based on Hybrid-hash provide good performance, but algorithms that require less replication will often produce as good or better performance, especially if each set-valued attribute references a small number of nodes. 1. Introduction Set-valued attributes are an important feature of next-generation database systems, both for Database Programming Languages (DBPLs) and Object-Oriented Database Systems (OODBSs). Examples of systems with datamodeling facilities for set-valued attributes include Bubba [BORA90], E [RICH92], GemStone [BUTT91], Iris [FISH87], LDL [CHIM90], O++ [AGRA89], ObjectStore [LAMB91], ORION [KIM90], and O 2 [DEUX91]. Setvalued attributes often contain the object identifiers (oids) of o..

Supporting Multiple View Maintenance Policies

Materialized views and view maintenance are becoming increasingly important in practice. In order to satisfy different data currency and performance requirements, a number of view maintenance policies have been proposed. Immediate maintenance involves a potential refresh of the view after every update to the deriving tables. When staleness of views can be tolerated, a view may be refreshed periodically or (on-demand) when it is queried. The maintenance policies that are chosen for views have implications on the validity of the results of queries and affect the performance of queries and updates. In this paper, we investigate a number of issues related to supporting multiple views with different maintenance policies. We develop formal notions of consistency for views with different maintenance policies. We then introduce a model based on view groupings for view maintenance policy assignment, and provide algorithms, based on the viewgroup model, that allow consistency of views to be guar..