Browse Prior Art Database

Type Modification in Object Oriented Database using Exception Handling

IP.com Disclosure Number: IPCOM000106828D
Original Publication Date: 1993-Dec-01
Included in the Prior Art Database: 2005-Mar-21
Document File: 2 page(s) / 80K

Publishing Venue

IBM

Related People

Al-Karmi, AA: AUTHOR [+3]

Abstract

This paper discloses a technique to handle schema evolution and type modification in the object oriented database by use of exception handling process. This allows dynamic solution to object type changes without having to encounter the performance, tools or instance invalidation problems if the type changes are enforced on instances each time type changes are made.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 52% of the total text.

Type Modification in Object Oriented Database using Exception Handling

      This paper discloses a technique to handle schema evolution and
type modification in the object oriented database by use of exception
handling process.  This allows dynamic solution to object type
changes without having to encounter the performance, tools or
instance invalidation problems if the type changes are enforced on
instances each time type changes are made.

      In object oriented databases, the issue of schema evolution and
type modification is still very much open.  These changes are facts
of life.  Once a type has its properties modified, the question is
how to reflect these changes in the existing instances.  One approach
could be to update all existing instances of that type to reflect
type changes.  This presents three major issues:

1.  Performance.  Each database might have millions of these
    instances

2.  Invalidation of tools.  Some existing tools might not work with
    the new type.

3.  Instance invalidation.  Some existing instance might not be
    modifiable to the new type.

      The other approach is to allow the instance evolution to occur
only when the user or a tool requests the object to its user space.
In another words, instances are updated when used at execution time
update.  This approach is dynamic and allows the change to occur only
when an object is touched.  Such a facility could be supported by
sending some sort of signal to the user, requesting an object, that
it does not meet the current schema definition.  This paper adopts
the exception handling mechanism to signal the fact of object type
changes to the users at the time of their use.  After recapturing the
errors through exception handling, it can re-represent, decide about
nature of error and find solution based on type change history.

      In order to properly represent the type changes or schema
evolution changes to objects, exception handling capability is used
to capture these changes as errors.  The Exception Handler Object
will then decide about the nature of that error and how to solve it
in view of the type change history.  Usually, errors that occur due
to such a type change is either:

1.  A program is trying to access an attribute or a method that is
    not defined in this instance.

2.  Or the program is trying to access a value that is not defined in
    the Object domain of acceptable values.

      This paper describes an approach to devise an Exception Handler
Object that captures these errors and processes them as seen fit.
This is explained in the following example.

TYPE      : Animal1                         Animal2

SUPERTYPE : Reptiles                        Reptiles

ATTRIBUTES: Habitat := {...