Object Database Conceptual Design
Section 11.4.1 discusses how object database (ODB) design differs from
relational database (RDB) design. Section 11.4.2 outlines a mapping algorithm
that can be used to create an ODB schema, made of ODMG ODL class definitions,
from a conceptual EER schema.
1. Differences between Conceptual Design of ODB and RDB
One of the main differences between ODB and RDB design is how
relationships are handled. In ODB, relationships are typically handled by
having relationship proper-ties or reference attributes that include OID(s) of
the related objects. These can be considered as OID references to the related objects. Both single references and
collections of references are allowed. References for a binary relationship
can be declared in a single direction, or in both directions, depending on the
types of access expected. If declared in both directions, they may be specified
as inverses of one another, thus enforcing the ODB equivalent of the relational
referential integrity constraint.
In RDB, relationships among tuples (records) are specified by attributes
with matching values. These can be considered as value references and are specified via foreign keys, which are values of primary key attributes repeated
in tuples of the referencing relation. These are limited to being
single-valued in each record because multivalued attributes are not permitted
in the basic relational model. Thus, M:N relationships must be represented not
directly, but as a separate relation (table), as discussed in Section 9.1.
Mapping binary relationships that contain attributes is not
straightforward in ODBs, since the designer must choose in which direction the
attributes should be included. If the attributes are included in both
directions, then redundancy in storage will exist and may lead to inconsistent
data. Hence, it is sometimes preferable to use the relational approach of
creating a separate table by creating a separate class to represent the
relationship. This approach can also be used for n-ary relationships, with degree n > 2.
Another major area of difference between ODB and RDB design is how
inheritance is handled. In ODB, these structures are built into the model, so
the mapping is achieved by using the inheritance constructs, such as derived (:) and extends. In relational design, as we
discussed in Section 9.2, there are several options to choose from since no
built-in construct exists for inheritance in the basic relational model. It is
important to note, though, that object-relational and extended-relational
systems are adding features to model these constructs directly as well as to
include operation specifications in abstract data types (see Section 11.2).
The third major difference is that in ODB design, it is necessary to
specify the operations early on in the design since they are part of the class
specifications. Although it is important to specify operations during the
design phase for all types of data-bases, it may be delayed in RDB design as it
is not strictly required until the implementation phase.
There is a philosophical difference between the relational model and the
object model of data in terms of behavioral specification. The relational model
does not mandate the database
designers to predefine a set of valid behaviors or operations, whereas this is
a tacit requirement in the object model. One of the claimed advantages of the
relational model is the support of ad hoc queries and transactions, whereas
these are against the principle of encapsulation.
In practice, it is becoming commonplace to have database design teams
apply object-based methodologies at early stages of conceptual design so that
both the structure and the use or operations of the data are considered, and a
complete specification is developed during conceptual design. These
specifications are then mapped into relational schemas, constraints, and
behavioral artifacts such as trig-gers or stored procedures (see Sections 5.2
and 13.4).
2. Mapping an EER
Schema to an ODB Schema
It is relatively straightforward to design the type declarations of
object classes for an ODBMS from an EER schema that contains neither categories nor n-ary relation-ships with n
> 2. However, the operations of classes are not specified in the EER dia-gram
and must be added to the class declarations after the structural mapping is
completed. The outline of the mapping from EER to ODL is as follows:
Step 1. Create an ODL class for each EER entity type or subclass. The type of the ODL class should include all the
attributes of the EER class.38 Multivalued attributes are
typically declared by using the set, bag, or list constructors. If the values of the multivalued
attribute for an object should be ordered, the list constructor is chosen; if
duplicates are allowed, the bag constructor should be chosen; otherwise, the
set constructor is chosen. Composite
attributes are mapped into a tuple constructor (by using a struct
declaration in ODL).
Declare an extent for each class, and specify any key attributes as keys
of the extent. (This is possible only if an extent facility and key constraint
declarations are avail-able in the ODBMS.)
Step 2. Add relationship properties or reference attributes for each binary
relation-ship into the ODL classes that participate in the relationship.
These may be created in one or both
directions. If a binary relationship is represented by references in both directions, declare the references
to be relationship properties that are inverses of one another, if such a facility exists. If a binary relationship is
represented by a reference in only one
direction, declare the reference to be an attribute in the refer-encing class
whose type is the referenced class name.
Depending on the cardinality ratio of the binary relationship, the
relationship properties or reference attributes may be single-valued or
collection types. They will be single-valued for binary relationships in the
1:1 or N:1 directions; they are collection types (set-valued or list-valued) for relationships in the 1:N or
M:N direction. An alternative way to map binary M:N relationships is discussed
in step 7.
If relationship attributes exist, a tuple constructor (struct) can be used to create a structure of the form <reference, relationship
attributes>, which may be included
instead of the reference attribute. However, this does not allow the use of the
inverse constraint. Additionally, if this choice is represented in both directions, the attribute values
will be represented twice, creating redundancy.
Step 3. Include appropriate operations for each class. These are not available
from the EER schema and must be
added to the database design by referring to the original requirements. A
constructor method should include program code that checks any constraints that
must hold when a new object is created. A destructor method should check any
constraints that may be violated when an object is deleted. Other methods
should include any further constraint checks that are relevant.
Step 4. An ODL class that corresponds to a subclass in the EER schema inherits
(via extends) the
type and methods of its superclass in the ODL schema. Its specific (noninherited) attributes, relationship references, and operations are
specified, as discussed in steps 1, 2, and 3.
Step 5. Weak entity types can be mapped in the same way as regular entity types.
An alternative mapping is possible
for weak entity types that do not participate in any relationships except their
identifying relationship; these can be mapped as though they were composite multivalued attributes of the
owner entity type, by using the set<struct<...
>> or list<struct<...
>> constructors. The attributes of the weak
entity
are included in the struct<... > construct, which corresponds to a tuple constructor. Attributes
are mapped as discussed in steps 1 and 2.
Step 6. Categories (union types) in an EER schema are difficult to map to ODL.
It is possible to create a mapping
similar to the EER-to-relational mapping (see Section 9.2) by declaring a class
to represent the category and defining 1:1 relationships between the category
and each of its superclasses. Another option is to use a union type, if it is
available.
Step 7. An n-ary relationship with degree
n > 2 can be mapped into a separate class, with appropriate references to each participating class. These
references are based on mapping a 1:N relationship from each class that
represents a participating entity type to the class that represents the n-ary relationship. An M:N binary
relationship, especially if it contains relationship attributes, may also use
this mapping option, if desired.
The mapping has been applied to a subset of the UNIVERSITY database schema in Figure 8.10 in the context of the ODMG object
database standard. The mapped object schema using the ODL notation is shown in
Figure 11.10.
Related Topics
Privacy Policy, Terms and Conditions, DMCA Policy and Compliant
Copyright © 2018-2024 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.