Object-oriented Database Schema Research Articles

Migrating to an object-oriented database using semantic clustering and transformation rules

This paper presents a methodology for handling an important step of database migration. The methodology is based on a set of techniques: (i) semantic clustering, (ii) metamodeling, and (iii) knowledge-based schema transformation. Semantic clustering (i.e., grouping based on semantic cohesion) is mainly used to facilitate the process of translating an extended entity relationship schema into a schema of complex objects. Meta modeling is used to define the data models involved in the process of schema transformation. Finally, transformation rules are defined and used for mapping a schema from a source model into a schema expressed in a target model. In this paper, we limit ourselves to the mapping of an extended entity relationship diagram into an object-oriented database schema using the object model supported by the ODMG standard.

Supporting update propagation in object-oriented databases

Objects in a database are interrelated. When an update operation is applied to an object, it may also impact on its related objects, depending on the semantics of their relationships. Current OODBMSs provide no support for update propagation but hard-coding. In this paper, we study update propagation support for generic update operations in object-oriented databases. We take a declarative approach, specifying propagation policies for each identified reference attribute in classes of an object-oriented database schema. Propagation policies for generic update propagation are well defined. However, we also discover that potential conflicts among propagation policies may occur if the policies can be arbitrarily specified by a designer. Therefore, we promote the update propagation problem to a higher level, investigating possible dependencies between objects. As such, the designer only needs to specify the dependency property for each reference attribute. Propagation policies are predefined for each type of dependency. By introducing some restrictions on an object-oriented database schema, conflict-free propagation policies can be achieved. Implementation issues for update propagation support in object-oriented database systems are also addressed.

Object-oriented database schema analysis and inheritance processing: A graph-theoretic approach

In this paper we address the inheritance process in the context of strongly typed Object-oriented database (OODB) systems, allowing multiple inheritance and overriding. For such powerful systems, it is important to analyse the inheritance hierarchy to identify a number of significant properties. The first, schema consistency, is connected to the inheritance conflicts. In the presence of an unsolvable inheritance conflict there is a contradiction in the schema. The second property is related to the termination of the inheritance process. We expect that all the subtypes in the schema, if consistent, can be rewritten in expanded form, after inheritance, in a finite time. Schemas that guarantee these two formal properties will be referred to as correct schemas. In the paper a graph-theoretic method is provided, aimed at supporting the designer in checking the correctness and deriving the expanded form of a schema. Furthermore, from the analysis of the complexity of the inheritance process, a third formal property has been defined, concerning the degree of compactness achievable in a schema, by using inheritance hierarchies. In particular, a class of schemas has been defined, referred to as logarithmic schemas, whose expanded forms, after inheritance, become exponential in the size of the original schemas.

Computing access relevance for path-method generation in OODB and IM-OODB

A path-method (PM) is a mechanism to retrieve or to update information relevant to one class, in an object-oriented database (OODB), that is not stored with that class but with some other class. The PM traverses a chain of classes and connections that ends at the class where the required information is stored. However, it is a difficult task for a user to write PMs. This is because it might require comprehensive knowledge of many classes of the conceptual schema. But a typical user has often incomplete or even inconsistent knowledge of the schema. Currently we are developing a system, called Path-Method Generator (PMG), which generates PMs automatically according to a naive user's requests. One algorithm of PMG uses numerical access relevance between pairs of classes as a guide for the traversal of an OODB schema. In this paper we define the notion of access relevance to measure the significance of the (indirect) connection between any two classes in an OODB and present efficient algorithms to compute access relevance. The manual PM generation in an interoperable multi object-oriented database (IM-OODB) is even more difficult than for one OODB since a user has to be familiar with several OODBs. We use a hierarchical approach for developing efficient online algorithms for the computation of access relevances in an IM-OODB, based on precomputed access relevances for each autonomous OODB. In an IM-OODB the access relevances are used as a guide in generating PMs between the classes of different OODBs.

A database manager for cell based VLSI circuits

CELLMAN, an object-oriented database manager for cell-based VLSI circuits is presented. With m constraints and n cells in the working set, the tool is capable of finding matching cells in O( m In n) time which is a significant speed up from the conventional relational database systems. An effective and efficient object-oriented database schema is developed for the cell based design environment. Efficient objective functions are developed to guide the search process. For function queries, technologies for Boolean matching is proposed with a constant time complexity, i.e., independent of the size of library. Techniques are developed to find closest misses when no cell satisfies the constraints provided by circuit designers. The tool has a user-friendly interface and is capable to be used in various environments. In addition, CELLMAN has inherited all advantages of object-oriented systems, including high performance, easy maintenance, inheritance, data abstraction, and has laid down an important foundation for designing extremely complicated circuits and systems. In fact, currently CELLMAN is being used in designing Intel's most advanced microprocessors.

Normalization in OODB design

When we design an object-oriented database schema, we need to normalize object classes as we do for relations when designing a relational database schema. However, the normalization process for an object class cannot be the same as that of a relation, because of the distinct characteristics of an object-oriented data model such as complex attributes, collection data types, and the usage of object identifiers in place of relational key attributes. We need only one kind of dependency proposed here -- the object functional dependency -- which specifies the dependency of object attributes with respect to the object identifier. We also propose the object normal form of an object class, for which all determinants of object functional dependencies are object identifiers. There is no risk of update anomalies as long as all object classes are in the object normal form.

Conceptual design of object-oriented database schemas using the binary-relationship model

We describe an algorithmic method for transforming a binary-relationship (BR) conceptual schema to an object-oriented (OO) database schema. The BR schema is a semantically rich diagram that represents the reality being modeled in terms of objects, relationships and constraints. It is easy to understand and serves as a communication tool between users and designers. Therefore it can be created in the early stages of system development, and later on be transformed into a specific OO database schema. The transformation method employs a multi-stage algorithm, which first identifies the essential objects in the BR schema, together with their relationships and constraints. These are then mapped to object classes, attributes, and constraints, maintaining the semantics and all types of constraints present in the conceptual schema.

On resolving schematic heterogeneity in multidatabase systems

The objective of a multidatabase system is to provide a single uniform interface to accessing multiple independent databases being managed by multiple independent, and possibly heterogeneous, database systems. One crucial element in the design of a multidatabase system is the design of a data definition language for specifying a schema that represents the integration of the schemas of multiple independent databases. The design of such a language in turn requires a comprehensive classification of the conflicts (i.e., discrepancies) among the schemas of the independent databases and development of techniques for resolving (i.e., homogenizing) all of the conflicts in the classification. An earlier paper provided a comprehensive classification of schematic conflicts that may arise when integrating multiple independent relational database (RDB) schemas into a single multidatabase (MDB) schema. In this paper, we provide a comprehensive classification of techniques for resolving the schematic conflicts that may arise when integrating multiple RDB schemas, or RDB schemas and object-oriented database (OODB) schemas, or multiple OODB schemas. The classification of conflict resolution techniques includes not only those necessary for resolving schematic conflicts identified in the earlier paper, but also additional conflicts that arise when OODBs become part of the databases to be integrated. Most of the conflict resolution techniques discussed in the paper have already been incorporated into SQL/M, a multidatabase language implemented in UniSQL/M, a commercially available multidatabase system from UniSQL, Inc. which integrated SQL-based relational database systems and the UniSQL/X unified relational and object-oriented database system.

Identifying extended entity-relationship object structures in relational schemas

Relational schemas consisting of relation-schemes, key dependencies and key-based inclusion dependencies (referential integrity constraints) are considered. Schemas of this form are said to be entity-relationship (EER)-convertible if they can be associated with an EER schema. A procedure that determines whether a relational schema is EER-convertible is developed. A normal form is proposed for relational schemas representing EER object structures. For EER-convertible relational schemas, the corresponding normalization procedure is presented. The procedures can be used for analyzing the semantics of existing relational databases and for converting relational database schemas into object-oriented database schemas.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Constraint analysis: a design process for specifying operations on objects

A design process for an object-oriented database design environment, known as constraint analysis, is presented. Given the increased level of semantics associated with an object-oriented database schema, constraint analysis makes use of semantics expressed as database constraints to support the flexible specification of propagation actions for operations on objects. Constraints are formally represented using Horn logic. The constraint analysis process then reasons about constraints at design time to help the designer understand the effects of constraints on object manipulation, identifying possible constraint violations as well as design alternatives for handling violations. An advantage of constraint analysis is that both inherent and explicit schema constraints are included in the analysis process. A formal representation is given that supports the analysis of constraints and the automatic identification of design alternatives for responding to constraint violations. >

Intermedia: A case study of the differences between relational and object-oriented database systems

This paper compares two approaches to meeting the data handling requirements of Intermedia, a hypermedia system developed at the Institute for Research in Information and Scholarship at Brown University. Intermedia, though written using an object-oriented programming language, relies on a traditional relational database management system for data storage and retrieval. We examine the ramifications of replacing the relational database with an object-oriented database. We begin by describing the important characteristics each database system. We then describe Intermedia and give an overview of its architecture and its data handling requirements. We explain why and how we used a relational database management system and the problems that we encountered with this system. We then present the design of an object-oriented database schema for Intermedia and compare the relational and object-oriented database management system approaches .