Object Oriented

DBMS
Database that stores data elements as

objects. Uses object-oriented concepts.

The term object oriented is

abbreviated by OO or O-O
 Object
 The entity that contains both attributes as well as
the actions associated with it
 The object has two components
1. State
2. behavior
 Attributes can be classified into simple and
complex
 An object is described by following characteristics
Identifier: a system-wide unique id for an object
Name: an object may also have a unique name in
DB (optional)
Lifetime: determines if the object is persistent or
transient
A simple attribute can be an
integer, string, real and so on.
Which takes on specific values.
 A complex attribute can contain
collection and/or references.
 A reference attribute represent a
relationship between objects and
contain a value or values.
Example

Object attributes for branch instance

Attribute Values
BranchNo B003 simple
Street 163 main st
City Islamabad
Postcode 22010
SalesStaff Ali khan; Atif khan c/r
Manager Amjad khan
BranchNo is example of simple
attribute with value B003
The attribute Salesstaff is collection
of staff objects.
Salestaff is example of reference
attribute.
The reference attribute is similar to
foreign key in the relational
DBMS.
Features of OO
1.Object Identity
 An OO database provides a unique
identity to each independent object
stored in the database.
 This unique identity is implemented via
a unique system generated object
identifier OID.
 The value of OID is not visible to the
user but it is used internally by the
system to identify each object uniquely.
 The main property required of an OID
is that it be immutable that is the OID
value of a particular object should not
change.
 It is also desirable that each OID be
used only once, that is even the object
is removed from the database its OID
should not be assigned to another
object.
 OID cannot be modified by the user.
2.Abstraction
 Abstraction is the process of
identifying the essential aspects of an
entity and ignoring the unimportant
properties.
 There are two fundamental aspects of
abstraction
1. Encapsulation
2. Information hiding
 Encapsulation
 The concept of encapsulation means that an object contains
both data structure and the set of operations that can be
used to manipulate it.
 Example

Define class Employee:

type tuple( name: string;
birthdate: date;
salary: float; );
operations create-emp: employee;
destroy-emp: boolean;
End employee;
Information hiding
 The concept of information hiding is that we
separate the external aspects of an object
from its internal details.
 The internal details are hidden from the user.
 So that the internal details can be changed
without affecting the application that use it,
that is the external details remain the same.
 User only knows available methods and how
to call them.
3.Methods and Messages

 In object technology functions are usually

called methods.
 Methods define the behavior of the object.
 They can be used to change the object’s state
by modifying its attribute values
 A method consist of a name and a body that
perform the action associated with method
name
Example
method void updatesalary(float increment)
{
Salary=salary+increment
}
It is a method use to update a member of
staff’s salary.
Messages
Messages are the means by which objects
communicate. A message is simply a
request from one object to another
asking the object to execute one of its
methods.
 Example
Staffobject.updatesalary(100)
4.Classes
Classes are used to define a set of similar
objects.
 Objects having same attributes and
respond to same messages can be
grouped together to form a class.
Example
class
Branchno=b003
City=london
BRANCH Postcode=78jj

attributes
branchno
city Branchno=b005
postcode City=london
Postcode=09jik
methods
print()
getpostcode()
Subclasses, Superclasses
and inheritance
Some objects may have similar but not
identical attributes and methods. If there
is a large degree of similarity, it would
be useful to be able to share the common
properties.
Inheritance allows one class to be
defined as a special case of a more
general class.
These special cases are known as
subclasses and the more general cases
are known as superclasses.
There are several forms of inheritance
1. Single inheritance

2. Multiple inheritance

3. Repeated inheritance

4. Selective inheritance
 Single inheritance:

Single inheritance refers to the fact that

the subclasses inherit from no more
than one superclass.
Example

person
Superclasses

Staff is also a subclass staff

Of a superclass
person

manager SalesStaff

subclasses
Multiple inheritance
 Multiple inheritance refer that the
subclass inherit from more than one
superclasses.
Example:
manager SalesStaff

salesmanager
 The multiple inheritance is very
problematic . The conflict arises when
the superclasses contain the same
attributes or method.
 It can be handled by the following ways:
 Include both attributes/method and use
the name of the superclass as qualifier
For example if bonus is attribute of both
manager and SalesStaff the subclass
salesmanager can inherit bonus from
both, and qualify bonus in salesmanager
as either manager.bonus or
SalesStaff.bonus
 Use single inheritance to avoid conflict
For example
Salesmanager manager salesstaff
Or
Salesmanager salesstaff manager
 Repeated inheritance
It is a special case of multiple inheritance in
which the superclasses inherit from a
common superclass.
The inheritance mechanism must ensure that the
subclass does not inherit properties from the
superclass twice.
 The multiple inheritance is very
problematic . The conflict arises when
the superclasses contain the same
attributes or method.
 It can be handled by the following ways:
 Include both attributes/method and use
the name of the superclass as qualifier
For example if bonus is attribute of both
manager and SalesStaff the subclass
salesmanager can inherit bonus from
both, and qualify bonus in salesmanager
as either manager.bonus or
SalesStaff.bonus
Example

staff

manager salesstaff

salesmanager
Selective inheritance
 It allows a subclass to inherit a limited
number of properties from the superclass.
Overriding and
overloading
Properties are automatically inherited
by subclasses from their superclasses.
However it is possible to redefine a
property in the subclass. This process
is called overriding.
 For example we might define a method in the
staff class to increment salary
Method void givecommission(float profit)
{
Salary=salary+0.02*profit;
}
However we may wish to perform a different
calculation for commission in manager subclass,
we can do this by redefing the overriding
Method void givecommission(float profit)
{
salary=salary+0.05*profit;
}
Overloading
 Overloading allows the name of a method
to be reused within a class definition.
This means that a single message can
perform different functions depending on
which object receive it.
For example:
Overloading print method for branch object
and staff object
Method void print()
{
Printf(“branchno%s”,branchno);
Printf(“city %s”,city);
Printf(“postcode%s”,postcode);
}

method void print()

{
Printf(“staffno%d”,staffno);
Printf(“name%s”,name);
Printf(“gender%c”,gender);
}
Storing objects in a relational
database
 Mapping classes to relations
There are number of strategies for mapping
classes to a relation but each result in a loss
of semantic information.
 Map each class to a relation

One approach is to map each class to a relation.

With this approach we loss the semantic
information of which class is superclass and
which one is subclass.
 Staff

Staffno
Name
Position
Dob
salary

Manager Salesperson
Secretary
Bonus Salesarea
mgrstartdate typingspeed
carallowance
Staff(staffno,name,position,dob,salary)
Manager(staffno,bonus,mgrstartdate)
Salesperson(staffno,salesarea,carallowence)
Secretary(staffno,typingspeed)
 Map each subclass to a relation

A second approach is to map each subclass

to a relation.
In this approach we lost semantic
information , it is no longer clear that the
relations are subclasses.
Manager(staffno,name,dob,position,salary,bonus,m
grstartdate)
Salesperson(staffno,name,dob,position,salary,sales
area,carallowence)
Secretary(staffno,name,dob,position,salary,typings
peed)
 Map the hierarchy to a single relation

The third approach is to map the entire hierarchy to

a relation.
Again we lost some semantic information and it
will produce an unwanted number of nulls for
attributes that do not apply to the tuple.
 Staff(staffno,name,dob,position,salary,bo
nus,mgrstartdate,salesarea,carallowence,t
ypingspeed)
 For example for a manager tuple the
attributes like
salesarea,carallowence,typingspeed will
be null.
Built-in interfaces for collection
objects
Any collection of object inherits the basic
collection interfaces such as:
 o.cardinality() operation returns the
number of elements in the collection.
 o.empty() returns true if the collection is
empty
 O.insert-element(e) and o.remove-
element(e) insert or remove an element
“e” from the collection o
 Automatic (user-defined) objects
 These are specified using keyword
class in ODL.
Class employee
{
attribute string name;
attribute date birthdate;
attribute enum gender{M,F} gender;
relationship department work-for

Void reassign(in string new-dname);

};
Object definition language
(ODL)
 The ODL is designed to create an object
database schema.
Class Class inheritance

relationships
1.1

1:N
M:N
 Has faculty

person department
offers
Works in
faculty student courses

students Has section

Registered in
advises section
gradstudent
advisor
Architecture

 Client—Server
Many commercial OODBMS based on the client—
server architecture.
However not a system uses same client—server
model, we can distinguish three basic
architecture for a client—server.
 Page server

In this approach most of the database processing is

performed by the client.
The server is responsible for providing pages at the
client’s request.
 Database server
In this approach most of the database processing is
performed by the server. The client simply
passes request to the server.
 Object server
This approach attempts to distribute the processing
between the two components. The server is
responsible to managing locks, recovery,
r=enforcing security and integrity. The client is
responsible for transaction management .