Efficiency in Instantiating Objects from Relational Databases Through Views

An integration of objects and databases provides a framework in which applications take advantage of the high productivity and reusability of an object-oriented software, and at the same time the sharability and maintainability of databases. One of the approaches for achieving this integration is to instantiate objects from relational databases through views. In this approach, a view is defined by a relational query and a function for mapping between object attributes and relation attributes. The query is used to materialize the necessary data into a relation from database, and the function is used to restructure the materialized relation into objects.

The approach of instantiating objects from relational databases through views provides an effective mechanism for building object-oriented applications on top of relational databases. However, a system built in such a framework has the overhead of interfacing between two different models - an object-oriented model and the relational model- in terms of both functionality and performance. In this thesis, we address two important problems: the outer join problem and the instantiation efficiency problem.

Outer join problem: In instantiating objects, tuples that should be retrieved from databases may be lost if we allow only inner joins. Hence it becomes necessary to evaluate certain join operations of the query by outer joins, left outer joins in particular. On the other hand, we sometimes retrieve unwanted nulls from nulls stored in databases, even if there is no null inserted during query processing. In this case, it is necessary to filter some relations with selection conditions which eliminate the tuples containing null attributes in order to prevent the retrieval of unwanted nulls. We develop a mechanism for making the system generate those left outer joins and filters as needed rather than requiring that a programmer specifies it manually as part of the query for every view definition. We also address how to reduce the number of left outer joins and filters for reducing the query processing time.

Instantiation efficiency problem: Since the advent of the relational databases, it has been universally accepted that a query result is retrieved as a single flat relation (a table). Such a relation is neither normalized nor nested if the query includes joins and has redundancies. This single table concept is not useful in our framework because a client wants to retrieve object instances. Rather, a single flat relation contains data redundantly inserted just to make the query result 'flat'. These redundant data convey no extra information but only degrade the performance of the system. This fact motivated us to look into different methods which reduce the amount of data that the system must handle to instantiate objects, without diminishing the amount of information to be retrieved. In this thesis, we present two alternative methods which retrieve a query result in less redundant structures than a single flat relation. Our result demonstrates that these two methods incur far less cost than the method of retrieving a single flat relation. We assume a computing environment that is a client-server architecture, where relational databases reside on servers and applications reside on connected workstations. Main memory database systems will benefit most from our work, although our work is useful for secondary storage database systems as well.