COSC 266

ADVANCED DATABASE MANAGEMENT

SYSTEM

Instructor : Getaneh Tilahun

 Chapter 1
Object-oriented Database

CoSc 266 : Advanced Database management System

Instructor : Getaneh Tilahun
Introduction
 Data
 Data is known facts that can be recorded and that have
implicit meaning.
For example
 Name of Employee
 Address of Employee etc…

 Data can be recorded in an indexed address book or it can

be stored on a hard drive, using a personal computer and
software such as Microsoft Access or Excel
Introduction
 Database
• A collection of related data with an implicit
meaning .
• A database has the following implicit properties:
 A database represents some aspect of the real

world, sometimes called the mini-world

 A database is a logically coherent collection of
data with some inherent meaning.
 A database is designed, built, and populated
with data for a specific purpose.
 It has an intended group of users and some

preconceived applications in which these users

are interested.
Introduction
 DBMS
 A database management system (DBMS) is a collection of
programs that enables users to create and maintain a
database.
 The DBMS is a general-purpose software system that
facilitates the processes of defining, constructing,
manipulating, and sharing databases among various users
and applications.
 There are two operation in DBMS
 DDL and
 DML

• Microsoft SQL, Oracle , MySQL, DB2,

Introduction
Types of Database
 File based system
 Adequate for small business
 Drawback
 Separation and Isolation of Data
 Each program/ Department store and maintain its own
data
 A user of one program may not aware the important of
the other data
 Duplication of Data

 Wasted time and space

 Data Dependency

 Incomputable file format

 Difficulty in accessing and querying data since a new

program has to be written to carry out each new task.

Introduction
–Types of Database
 Database based System

 Database systems solve all problems of file systems

 Data independence (logical, physical)

 Data integration

 Data consistency, lack of data redundancy

 Concurrent access, transactions, recovery, backup

 Querying (SQL)
Introduction – Types of Database
 Hierarchical/Network Database Model
 Suitable for data which are related

 Hierarchically start by defined tree of data node

 Each node can contain some identifying data, plus a set

of sub-nodes of a specific child type

 Relational Database
 Provides a conceptually simple model for data as relations
(typically considered “tables”) with all data visible.
Introduction – Types of Database
 Object Oriented Database Model

Goal:
Store object-oriented programming objects in a
database without having to transform them into
relational format
OODB were not commercially successful due to
 high cost of relational to object-oriented transformation
and a sound underlying theory, but they still exist
 as mentioned creating a standard.

This was attempted by the Object Data Management Group

(ODMG) which published five revisions to its standard. This
group was wound up in 2001.
Introduction – Types of Database
OODBMS

Hierarchical Data Model

Network Data Model

Relational Data Model

ER Data Model

Semantic Data Model

Object-Relational Data Model Object Oriented Data Model

Object Oriented Database
 Why Object Oriented database?
1. Traditional data models and systems, such as
relational, network, and hierarchical, have been
quite successful in developing the database
technologies required for many traditional business
database applications.
However, they have certain shortcomings when more
complex database applications must be designed and
implemented—for example, databases for engineering
design and manufacturing (CAD/CAM and CIM1),
scientific experiments, telecommunications, geographic
information systems , and multimedia
Object oriented database was proposed to meet some of the
needs of these more complex applications that store images,
videos or large textual items
 Object Oriented Database
2. Vast increase in the use of object-oriented programming
languages for developing software applications.
• Traditional databases are sometimes difficult to use with software
applications that are developed in an object-oriented
programming language such as C++ or Java.
• In traditional database systems, information about a complex
object is often scattered over many relations or records, leading to
loss of direct correspondence between a real-world object and its
database representation.
• Programming language and database data types and data
definition are completely different (an “impedance mismatch”)
• Object databases are designed so they can be directly—or
seamlessly—integrated with software that is developed using
OOPLs.

 The traditional DBMS /RDBMS software become object

database management systems (ODMS) or ODBMS or
OODBMS in object oriented database implementation.
Object
 The Object oriented (OO or O-O) has originated
in OO programming language or OOPLs such as
Java, C++
 But now a days OO concept is applied in the area
of Database, Software engineering, Knowledge
base, Artificial intelligence, and computer system
in general
 What is Object ?
 Object consists of entity and attributes which can
describe the state of real world object and action
associated with that object.
 An object typically has two components: state (value)
and behavior (operations)
Characteristics of Object
 Object name
The name is used to refer different objects in the program.
 Object identifier
This is the system generated identifier which is assigned,
when a new object is created.
 Structure of object
Structure defines, how the object is constructed using
constructor.
 In object oriented database the state of complex object can

be constructed from other objects by using certain type of

constructor.
 The formal way of representing objects as (i,c,v) where 'i' is

object identifier, 'c' is type constructor and 'v' is current

value of an object.
Characteristics of Object
 Transient object
 In OOPL, objects which are present only at the

time of execution are called as transient object.

 For example: Variables in OOPL

 Persistent objects
An object which exists even after the program is
completely executed (or terminated), is called as
persistent objects. Object-oriented databases can
store objects in secondary memory.
In other words, OO databases store persistent
objects permanently in secondary storage, and
allow the sharing of these objects among multiple
programs and applications
Object Identity
 One goal of an ODMS (Object Data Management
System) is to maintain a direct correspondence
between real-world and database objects so that
objects do not lose their integrity and identity.
 Hence, an ODMS provides a unique identity to
each independent object stored in the database
 Each object is assigned an Object Identifier
(OID) when it is created that is:
 system generated
 unique to that object
 immutable / invariant/ unchanged
 independent of the values of its attributes
 indivisible to the user
 used only once.
Object Structure
 Similar to Object Oriented Programming, OODB
objects can be constructed from other object
constructors.
 An object can be defined as a triple (i,c,v) . Where
 i is the object identifier,
 c is the type constructor, and
 v is the state or value of the object.
Type Constructors
In ODMS objects and literals may have a type structure
of arbitrary complexity in order to contain all of the
necessary information that describes the object
 The three most basic type constructors (types) are
atom, tuple, and collection.
Atom Constructor
 One type constructor has been called the atom constructor,
 The atom constructor is used to represent all basic atomic
values, such as integers, real numbers, character strings,
Booleans, and any other basic data types that the system
supports directly.
 They are called single-valued or atomic types, since each
value of the type is considered an atomic (indivisible) single
value.
Type Constructors
Tuple (Struct) constructor
 struct (or tuple) constructor. This can create standard structured
types, such as the tuples (record types) in the basic relational
model.
 A structured type is made up of several components, and is also
sometimes referred to as a compound or composite type.
For example, two different structured types that can be created are:
struct Name<FirstName: string,
MiddleInitial: char,
LastName: string>,
struct CollegeDegree <Major: string,
Degree: string,
Year: date>
Type Constructors
Collection (or multivalued) Constructor
 Collection constructors include the set(T), list(T), bag(T),
array(T), and dictionary(K,T) type constructors.
 These allow part of an object or literal value to include a
collection of other objects or values when needed.
 These constructors are also considered to be type
generators because many different types can be created.
For example,
 set(string), set(integer), and set(Employee) are three
different types that can be created from the set type
constructor. All the elements in a particular collection
value must be of the same type. For example, all values in
a collection of type set(string) must be string values.
Type Constructors
 Atom constructor is used to represent all basic atomic
values, such as integers, real numbers, character
strings, Booleans, and any other basic data types that
the system supports directly.
 The tuple constructor can create structured values
and objects of the form <a1:i1, a2:i2,...,an:in>, where
each aj is an attribute name and each ij is a value or
an OID
 The other commonly used constructors are collectively
referred to as collection types, but have individual
differences among them.
Type Constructors
 The set constructor will create objects or literals that are a set
of distinct elements {i1,i2,...,in},all of the same type.
 The bag constructor (sometimes called a multiset) is similar to
a set except that the elements in a bag need not be distinct.
 The list constructor will create an ordered list [i1,i2,...,in] of
OIDs or values of the same type.
 A list is similar to a bag except that the elements in a list are
ordered, and hence we can refer to the first, second, or jth
element.
 The array constructor creates a single-dimensional array of
elements of the same type. The main difference between array
and list is that a list can have an arbitrary number of elements
whereas an array typically has a maximum size.
 The dictionary constructor creates a collection of two tuples
(K, V), where the value of a key K can be used to retrieve the
corresponding value V.
Type Constructors
Object state interpreted by object constructors
Object Structure
Object structure can be defined by constructor
 Atomic
 Structured (tuple)
 Collection : set , List , bag, array

Example
i1, i2, i3, . . . to stand for unique system generated object identifiers. Consider
the following objects:
o1 = (i1, atom, ‘AddisAbaba’)
o2 = (i2, atom, ‘Jemo’)
o3 = (i3, atom, ‘Jimma’)
o4 = (i4, atom, 5)
o5 = (i5, atom, ‘Research’)
o6 = (i6, atom, ‘1988-05-22’)
o7 = (i7, set, {i1, i2, i3})
Object Structure

Example 1 (cont.)
 The first six objects listed in this example
represent atomic values.

 Object 7 is a set-valued object that

represents the set of locations for
department 5; the set refers to the atomic
objects with values {‘AddisAbaba’, ‘Jemo’,
‘Jimma’}.
Object Structure
Example 1 (cont.)
o8 = (i8, tuple, <dname:i5, dnumber:i4, mgr:i9,
locations:i7, employees:i10, projects:i11>)
o9 = (i9, tuple, <manager:i12,
manager_start_date:i6>)
o10 = (i10, set, {i12, i13, i14})
o11 = (i11, set {i15, i16, i17})
o12 = (i12, tuple, <fname:i18, minit:i19, lname:i20,
ssn:i21, . . ., salary:i26, supervi-sor:i27, dept:i8>)

Object 8 is a tuple-valued object that represents

department 5 itself, and has the attributes
DNAME, DNUMBER, MGR, LOCATIONS, and
so on.
Equal vs. Identical Objects
 Two objects are said to have identical
values, if the graphs representing their
values are identical in every respect,
including the OIDs at every level.
 Two object are said to have equal values
if their graph structure is the same, all
the corresponding atomic values should
also be the same (same states at the
atomic level) but their OID do not have
to be the same.
Equal vs. Identical Objects
 Example 2:
This example illustrates the difference between
the two definitions for comparing object states
for equality.
o1 = (i1, tuple, <a1:i4, a2:i6>)
o2 = (i2, tuple, <a1:i5, a2:i6>)
o3 = (i3, tuple, <a1:i4, a2:i6>)
o4 = (i4, atom, 10)
o5 = (i5, atom, 10)
o6 = (i6, atom, 20)

In this example, The objects o1 and o2 have

equal states, since their states at the atomic
level are the same but the values are reached
through distinct objects o4 and o5.
Equal vs. Identical Objects
Example 2 (cont.):
 However, the states of objects o1 and o3 are
identical, even though the objects
themselves are not because they have
distinct OIDs.
 Similarly, although the states of o4 and o5
are identical, the actual objects o4 and o5
are equal but not identical, because they
have distinct OIDs.
Type Constructors
Specifying the object types Employee, date, and Department
using type constructors
1.5 Encapsulation of Operations
Encapsulation
 One of the main characteristics of OO languages and systems
 related to the concepts of abstract data types and information
hiding in programming languages
 In relational database, the concept encapsulation was not applied,
since all tuple is visible to all users of the database.
 For example, in the relational model, the operations for selecting,
inserting, deleting, and modifying tuples are generic and may be
applied to any relation in the database

 Specifying Object Behavior via Class Operations:

 The main idea is to define the behavior of a type of object based on
the operations that can be externally applied to objects of that
type.

 For database applications, the requirement that all objects be

completely encapsulated is too stringent.
 One way of relaxing this requirement is to divide the structure of
an object into visible and hidden attributes (instance variables).
Encapsulation in OODBs
To encourage encapsulation, an operation is defined in
two parts:
 signature or interface of the operation, specifies the
operation name and arguments (or parameters).
 method or body, specifies the implementation of the
operation.
 Operations can be invoked by passing a message to
an object, which includes the operation name and
the parameters.
 The object then executes the method for that
operation.
Encapsulation in OODBs
 Some operations used to create (insert) or destroy
(delete) objects or update the object state or retrieve
parts of the object state or to apply some calculations
or perform a combination of retrieval, calculation,
and update
 Encapsulation permits modification of the internal
structure of an object, as well as the implementation
of its operations, without the need to disturb the
external programs that invoke these operations.
 The external users of the object are only made aware
of the interface or signature of the operations, which
defines the name and arguments (parameters) of
each operation
Encapsulation in OODBs
Adding operations to definitions of Employee and
Department:
Encapsulation in OODBs
 The number operation are declared for each class, and
the signature (interface) of each operation is included in
the class definition.
 A method (implementation) for each operation must be
defined elsewhere using a programming language
 Object constructor operation (often called new), which is
used to create a new object, and the destructor operation,
which is used to destroy (delete) an object.
 An operation is typically applied to an object by using the
dot notation.
For example,
 if d is a reference to a DEPARTMENT object, we can invoke an
operation such as no_of_emps by writing d.no_of_emps.
Similarly, by writing d.destroy_dept, the object
1.6 Methods and Persistence
 Specifying Object Persistence via
 Naming and
 Reachability
Naming
 The naming mechanism involves giving an object a
unique persistent name within a particular database.

 It is not practical to give names to all objects in a large

database , so objects are made persistent by using the
second mechanism called reachability
Reachability
 The reachability mechanism works by making the object
reachable from some other persistent object.
 An object B is said to be reachable from an object A if a
sequence of references in the database lead from object A
to object B.
Methods and Persistence
Creating persistent objects by naming and reachability
1.7 Type Hierarchies and Inheritance
Inheritance allows the definition of new types based
on other predefined types, leading to a type(or class)
hierarchy.
A type is defined by assigning it a type name, and then
defining a number of attributes (instance variables)
and operations (methods) for the type

Type (class) Hierarchy

 A type in its simplest form can be defined by it’s type
name and a listing of the names of its visible/public
functions. Attributes (instance variables) and operations
(methods) for the type are together called functions

 TYPE_NAME: function, function, . . . , function

1.7 Type Hierarchies and Inheritance
For example a type that describe a character of person

Example: PERSON: Name, Address, Birthdate, Age

Name, Address ,and Birth_date functions can be implemented as

stored attributes, whereas the Age function can be implemented as
calculated value.

Subtype: when the designer or user must create a new type that is
similar but not identical to an already defined type

Subtype: inherits all the functions of the predefined type (also

known as the super type)
1.7 Type Hierarchies and Inheritance
Type (class) Hierarchy
Example (1):
PERSON: Name, Address, Birthdate, Age, SSN

EMPLOYEE: Name, Address, Birthdate, Age, Salary,

Hire_Date, Seniority

STUDENT: Name, Address, Birthdate, Age, Major, GPA

OR:
Therefore, we can declare EMPLOYEE and STUDENT
as follows:
EMPLOYEE subtype-of PERSON: Salary, Hire_Date, Seniority

STUDENT subtype-of PERSON: Major, GPA

1.7 Type Hierarchies and Inheritance
Type (class) Hierarchy
A subtype includes all of the functions that are
defined for its supertype plus some additional
functions that are specific only to the subtype.

Hence, it is possible to generate a type hierarchy to

show the supertype/subtype relationships among all
the types declared in the system.
1.7 Type Hierarchies and Inheritance
Type (class) Hierarchy
Example (2):
consider a type that describes objects in plane geometry,
which may be defined as follows:

GEOMETRY_OBJECT type: Shape, Area, ReferencePoint

Now suppose that we want to define a number of

subtypes for the GEOMETRY_OBJECT type, as follows:

RECTANGLE subtype-of GEOMETRY_OBJECT: Width,

Height
TRIANGLE subtype-of GEOMETRY_OBJECT: Side1, Side2,
Angle
CIRCLE subtype-of GEOMETRY_OBJECT: Radius
1.7 Type Hierarchies and Inheritance
Type (class) Hierarchy
Example (2):
Notice that the Area operation may be implemented by a
different method for each subtype,

since the procedure for area calculation is different for

rectangles, triangles, and circles.

Similarly, the attribute Reference_point may have a different

meaning for each subtype;

it might be the center point for RECTANGLE and CIRCLE

objects, and the vertex point between the two given sides for a
TRIANGLE object.
1.7 Type Hierarchies and Inheritance
Type (class) Hierarchy
Example (2) (cont.):
An alternative way of declaring these three subtypes is
to specify the value of the Shape attribute as a condition
that must be satisfied for objects of each subtype:

RECTANGLE subtype-of GEOMETRY_OBJECT

(Shape=‘rectangle’): Width, Height

TRIANGLE subtype-of GEOMETRY_OBJECT

(Shape=‘triangle’): Side1, Side2, Angle

CIRCLE subtype-of GEOMETRY_OBJECT (Shape=‘circle’):

Radius
1.8 Polymorphism
 Polymorphism is another characteristics of OO system
that provide two or more function using one method.
 It allows the same operator/Method name or symbol to
bound (give)to two or more different implementation of
operation , depending on the type of object to which the
operator is applied.
 Polymorphism also called operator overloading

 Polymorphism can be applied using method

overloading or method overriding.
1.8 Polymorphism
Example 2
STAFF_OBJECT type: salary,
void givecommission(float profit) {
Salary=salary+0.02*profit; }

Manager subtype-of STAFF_OBJECT :

void givecommission(float profit) {
salary=salary+0.05*profit; }

we might define a method in the staff class to increment

salary However we may wish to perform a different
calculation for commission in manager subclass, we can do
this by redefine the method givecommission in manager sub
object as shown above and called method overriding
1.8 Polymorphism
Example 1- Overloading
GEOMETRY_OBJECT type: Shape, Area, ReferencePoint

RECTANGLE subtype-of GEOMETRY_OBJECT

(Shape=‘rectangle’): Width, Height

TRIANGLE subtype-of GEOMETRY_OBJECT

(Shape=‘triangle’): Side1, Side2, Angle

CIRCLE subtype-of GEOMETRY_OBJECT (Shape=‘circle’):

Radius
1.9 MULTIPLE AND SELECTIVE INHERITANCE
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
1.9 MULTIPLE AND SELECTIVE INHERITANCE
Multiple inheritance
There are several techniques for dealing with ambiguity
in multiple inheritance.
1. One solution is to have the system check for
ambiguity when the subtype is created, and to let the
user explicitly choose which function is to be
inherited at this time.
2. A second solution is to use some system default.

3. A third solution is to disallow multiple inheritance

altogether if name ambiguity occurs, instead forcing
the user to change the name of one of the functions in
one of the supertypes.
1.9 MULTIPLE AND SELECTIVE INHERITANCE
Selective inheritance
 It allows a subclass to inherit a limited number of
properties from the superclass.
 An EXCEPT clause may be used to list the functions in a
supertype that are not to be inherited by the subtype.
END OF CHAPTER ONE